@polycode-projects/the-mechanical-code-talker 1.0.8 → 1.2.0

package/src/chat.mjs

@@ -52,7 +52,10 @@ import { createTelemetry } from "./telemetry.mjs";
 import * as defaultSource from "./source.mjs";
 import { loadTemplates, render as renderTemplate } from "./corpus/templates.mjs";
 import { finish, beginsWithVowelSound, grammarRules } from "./finish.mjs";
-import { VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE, PASSIVE_PARTICIPLE_TO_KIND } from "./ask-vocab.mjs";
+import {
+  VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE, PASSIVE_PARTICIPLE_TO_KIND,
+  stripTrailingScopeFiller,
+} from "./ask-vocab.mjs";
 import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames } from "./interpret/normalize.mjs";
 import { fuzzyMatchInSet, fuzzyBound } from "./interpret/fuzzy.mjs";
 
@@ -228,8 +231,10 @@ function withNarration(result, trace, fallbackGoal) {
  *  own test suite pins composed answers with (see withGoalLine's own docblock,
  *  just below, for why appended rather than led-with).
  *
- *  `result.goal` is set ONLY by runAsk (see its own docblock at its return
- *  statement) — a plain count, a slash-command or a teach confirmation never
+ *  `result.goal` is set by runAsk (see its own docblock at its return
+ *  statement) AND by runCommand's own mk() (Bug F point 5 — GOAL_BY_COMMAND,
+ *  below — generalizes the SAME mechanism to slash-command dispatches like
+ *  /search and /describe); a plain count or a teach confirmation never
  *  carries the field, so this is a no-op for those turn types BY
  *  CONSTRUCTION, not a special-cased suppression list here. Also a no-op when
  *  `result.goal` is null/empty — deduceGoalFromParsed's own "nothing to
@@ -370,12 +375,23 @@ function looksLikePredicateFind(restTok) {
 export function asBareCommand(line) {
   const trimmed = String(line || "").trim();
   if (!trimmed || trimmed.startsWith("/")) return null;
-  const [first, ...restTok] = trimmed.split(/\s+/);
+  const [first, ...restTokRaw] = trimmed.split(/\s+/);
   if (!COMMAND_WORDS.has(first.toLowerCase())) return null;
   const fl = first.toLowerCase();
+  // Bug F point 2 (operator follow-up request): "search for X" (bare, via this
+  // function) used to route with "for X" as the literal command argument — "for"
+  // is filler, not part of the search term, and burning one of the 3 allowed
+  // tokens on it could wrongly reject an otherwise-short query as "too long"
+  // ("search for the payment controller" is 4 tokens WITH "for", 3 without).
+  // Strip a leading "for " before it becomes the argument, and rebuild the
+  // returned command line from the STRIPPED remainder — the token-count check
+  // below already reads the stripped `restTok`/`rest`.
+  const stripped = (fl === "search" || fl === "find") && restTokRaw[0]?.toLowerCase() === "for";
+  const restTok = stripped ? restTokRaw.slice(1) : restTokRaw;
   const rest = restTok.join(" ");
+  const effectiveLine = stripped ? `${fl}${rest ? ` ${rest}` : ""}` : trimmed;
   // Zero-arg system commands are always the command; a bare command word is too.
-  if (!rest || fl === "stats" || fl === "memory") return `/${trimmed}`;
+  if (!rest || fl === "stats" || fl === "memory") return `/${effectiveLine}`;
   // "find" (only — "search", its /find-tool alias, keeps its original behavior
   // unconditionally): the predicate-find grammar's own shape wins regardless of
   // word count, see the precedence note above.
@@ -398,7 +414,7 @@ export function asBareCommand(line) {
   if (COMMANDS[fl]?.arg == null && rest) return null;
   // Arg commands: route only a short, name-like argument (no query connectives),
   // so "describe Widget" / "members my class" route but a compositional query does not.
-  if (restTok.length <= 3 && !QUERY_CONNECTIVES.test(rest)) return `/${trimmed}`;
+  if (restTok.length <= 3 && !QUERY_CONNECTIVES.test(rest)) return `/${effectiveLine}`;
   return null;
 }
 
@@ -525,7 +541,18 @@ export function answerCount(graph, query) {
   const cls = COUNT_NOUNS[noun];
   if (cls && RESTRICTOR_VERB_RE.test(String(query).slice(m.index + m[0].length))) return null;
   if (!cls) {
-    return `I can't count "${noun}". I count: ${countableKinds(graph).join(", ")}. ` +
+    const kinds = countableKinds(graph);
+    // Bug C (operator manual-chat find, this session): when NO code graph is
+    // loaded, countableKinds(graph) is genuinely EMPTY (no class is present at
+    // all) — the old message rendered "I count: ." (a dangling empty list
+    // before the period) and then pointlessly suggested "how many classes are
+    // there", which would ALSO fail for the same reason. An honest, non-dangling
+    // message instead, pointing at how to actually get a graph loaded.
+    if (!kinds.length) {
+      return `I can't count "${noun}" — no code graph is loaded yet, so there's nothing to count ` +
+        `(point me at one with --repo, or run "npm run example:mini").`;
+    }
+    return `I can't count "${noun}". I count: ${kinds.join(", ")}. ` +
       `Try "how many classes are there".`;
   }
   const n = countClass(graph, cls);
@@ -673,6 +700,39 @@ const CAPABILITY_PHRASES = [
   // today (bin/tmct.mjs), dead once inside the chat loop; route to the same
   // capability answer a plain "help" gets.
   /^--help$/i, /^-h$/i, /^man( tmct)?\??$/i,
+  // Tier 6 playtest ("the messy real user", §3): the vague-opener family a
+  // stranger genuinely asks before knowing any query shapes — "what can you
+  // tell me about this repo", "tell me something interesting (about this
+  // codebase)", "so, what is going on in this codebase" (an optional leading
+  // "so," discourse connective, same species as LEADING_CONNECTIVE_RE
+  // elsewhere). All three used to fall straight to the raw grammar wall
+  // (isConversational's own ≤3-word/no-codeish catch-all never claims an
+  // 8-word sentence like these) even though orientationAnswer is EXACTLY the
+  // right answer — the same overview CAPABILITY_PHRASES' other entries already
+  // reach. The noun set mirrors META_ORIENT_RE's own closed list.
+  /^what can (?:you|u) tell me(?:\s+(?:more|anything))?\s+about (?:this|the)\s+(?:app|codebase|repo|repository|project|code|thing)\??$/i,
+  /^tell me something interesting(?:\s+about (?:this|the)\s+(?:app|codebase|repo|repository|project|code))?\??$/i,
+  /^(?:so,?\s+)?what(?:'s|s|\s+is)\s+(?:going on|happening)\s+(?:in|with)\s+(?:this|the)\s+(?:app|codebase|repo|repository|project|code)\??$/i,
+  // Tier 6 playtest cycle 2: three more vague-opener idioms found live, same
+  // family as the three just above — a stranger's orientation request has no
+  // fixed wording, so this closed set keeps growing additively as new natural
+  // phrasings surface, never a general "any long question is an orientation
+  // request" rule.
+  /^(?:can you\s+)?walk me through (?:this|the)\s+(?:app|codebase|repo|repository|project|code)\??$/i,
+  /^what(?:'s|s|\s+is) the big picture(?:\s+here)?\??$/i,
+  /^(?:give me|what's) the lay of the land\??$/i,
+  // Tier 6 playtest cycle 3: "what have we got here"/"what've we got here" —
+  // a casual, self-answering opener (found after a leading "so" strips via
+  // LEADING_CONNECTIVE_RE, leaving this as the bare remainder).
+  /^what(?:'ve| have) (?:we|i) got here\??$/i,
+  // "what's in this repo/codebase" — arguably the MOST natural vague opener of
+  // this whole family, and genuinely ambiguous with the real "what's in <X>"
+  // members/containment grammar (ask.mjs) for any OTHER term — closed to
+  // exactly the same self-referential noun set META_ORIENT_RE already uses,
+  // so a real module/class named literally "repo"/"codebase" is never at risk
+  // (this repo's own fixture has none, and the noun list itself excludes
+  // ordinary code-ish names).
+  /^what(?:'s|s|\s+is) in (?:this|the)\s+(?:app|codebase|repo|repository|project|code)\??$/i,
 ];
 /** IDENTITY questions — "who/what are you", by name, in plain or ESL-ish phrasing.
  *  Routed to a self-description (identity-self) that works regardless of graph
@@ -831,6 +891,11 @@ const THANKS = new Set([
   "thanks", "thank you", "thankyou", "thx", "ty", "ta", "cheers", "nice one",
   "much appreciated", "cool thanks", "many thanks", "much obliged", "ta very much",
   "cheers mate", "cheers for that", "tks", "sweet thanks", "nice",
+  // "ta for that" (Tier 6 playtest): "cheers for that" was already here, but
+  // its "ta" sibling (both dropped-word forms of the SAME "thanks for that"
+  // shape) was missing — fell to the generic orientation card via
+  // isConversational's ≤3-word catch-all instead of a thanks reply.
+  "ta for that",
 ]);
 /** Farewells → a goodbye AND a clean end of session (same path as /exit). */
 const BYE = new Set([
@@ -1034,7 +1099,16 @@ function conversationalTurn(line, ctx) {
     note(ctx.trace, "lane: conversational — identity (IDENTITY_PHRASES closed set)");
     return mk(t(T_IDENTITY_SELF));
   }
-  if (q === "help" || q === "?" || CAPABILITY_PHRASES.some((re) => re.test(raw)) || ORIENT_OPENERS.has(q)) {
+  // Tier 6 playtest cycle 2: CAPABILITY_PHRASES' vague-opener entries are
+  // self-contained closed regexes, but a preamble ahead of one ("right, can
+  // you walk me through this codebase" — an ACK_PREAMBLE_RE + MODAL_WRAPPER_RE
+  // stack) is tested nowhere upstream of this check, unlike vagueTouchTermOf/
+  // describeWrapperAnswer (both run applyPreambleFrames first). Trying the
+  // SAME closed set again against the preamble-stripped text is purely
+  // additive — it can only ever ADD a match CAPABILITY_PHRASES.test(raw)
+  // alone would have missed, never take one away.
+  if (q === "help" || q === "?" || CAPABILITY_PHRASES.some((re) => re.test(raw))
+    || CAPABILITY_PHRASES.some((re) => re.test(applyPreambleFrames(raw))) || ORIENT_OPENERS.has(q)) {
     note(ctx.trace, "goal: get oriented — what can tmct answer, how do I start");
     note(ctx.trace, "lane: conversational — help/orientation (CAPABILITY_PHRASES/ORIENT_OPENERS / bare help / ?)");
     return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint));
@@ -1251,7 +1325,13 @@ const WALL_MISS_ANYWHERE_RE = /couldn't parse this as a graph question\. Try:/;
 //     silently swallowed);
 //   - "<Name> owns/maintains <X>" (bare declarative or wrapped) → an
 //     mgx:ownedBy fact, read back by "who owns <X>" (factReadBack).
-const TEACH_RE = /^(?:please\s+)?(?:remember|note|keep in mind|jot down|for the record|fyi)\b[:,]?\s*(?:that\s+)?(.+?)[.?!]*$/i;
+// Bug F point 1 (operator follow-up request, this session): "I want you to
+// remember X"/"I'd like you to remember X" teaches exactly like bare "remember
+// X" — a closed-set optional lead-in before the existing verb list, so it
+// 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;
 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. */
@@ -1274,16 +1354,46 @@ const SUBCLASS_PREDICATE = "rdfs:subClassOf";
 const HAS_A_PREDICATE = "mgx:hasA";
 
 /** "<Name> owns/maintains <X>" — the ownership teach declarative. <Name> is one
- *  or two name tokens, <X> one code-ish token (a path, a file, a symbol). The
- *  BARE form additionally requires a Capitalized name (see teachLane), so
- *  ordinary lowercase prose never lands a fact without the explicit wrapper. */
-const OWNS_TEACH_RE = /^([A-Za-z][\w'-]*(?:\s+[A-Z][\w'-]*)?)\s+(?:owns|maintains)\s+(\S+?)[.!?]*$/;
+ *  or two name tokens; <X> is a code-ish token (a path, a file, a symbol) OR a
+ *  short natural noun phrase ("the tasks handler") — widened from a
+ *  single-token-only object (Tier-5 playtest fix, found live: "remember that
+ *  margo maintains the tasks handler" WALLED entirely, because the object
+ *  didn't fit ONE bare token and generalVerbTeach explicitly stands down for
+ *  "owns"/"maintains" anywhere in the sentence, deferring to this frame — so
+ *  neither recognizer ever stored the fact). The article-stripping needed so
+ *  "the tasks handler" reads back the same as a bare "tasks handler" is
+ *  handled once, centrally, by normFactTerm (memory/core.mjs) — teachFact
+ *  already normalizes both subject and object through it. The BARE form
+ *  additionally requires a Capitalized name (see teachLane), so ordinary
+ *  lowercase prose never lands a fact without the explicit wrapper. */
+const OWNS_TEACH_RE = /^([A-Za-z][\w'-]*(?:\s+[A-Z][\w'-]*)?)\s+(?:owns|maintains)\s+(.+?)[.!?]*$/;
+/** "<X> is owned by <Name>" — the PASSIVE ownership teach declarative
+ *  (Tier-5 playtest fix, cycle 2, found live): at least as natural a way to
+ *  state ownership as the active "<Name> owns <X>" above ("TaskController is
+ *  owned by sam" WALLED entirely — "is" put it in generalVerbTeach's own
+ *  GENERAL_VERB_ANYWHERE_EXCLUDE_RE stand-down territory, but no frame in
+ *  this lane actually recognized the passive shape, so nothing ever claimed
+ *  it). <X> (the owned thing) is a lazy multi-word capture, same discipline
+ *  OWNS_TEACH_RE's own object got widened to; <Name> (the owner) mirrors
+ *  OWNS_TEACH_RE's own 1-2-token name capture. Stores the SAME
+ *  OWNED_BY_PREDICATE shape (subject=thing, object=owner), so "who owns X" /
+ *  the yes/no readers below answer either phrasing identically. */
+const OWNS_PASSIVE_TEACH_RE = /^(.+?)\s+(?:is|are|was|were)\s+owned\s+by\s+([A-Za-z][\w'-]*(?:\s+[A-Z][\w'-]*)?)[.!?]*$/i;
 
 /** "<X> is <adjective>" — the property teach payload (wrapper-REQUIRED): a lazy
  *  subject and a single bare complement word. Never matches the "is a <noun>"
  *  membership shape (that stays the ACE grammar's), so "remember that cache is
- *  a store" still lands as rdfs:subClassOf, not a property. */
-const TEACH_PROPERTY_RE = /^(?:every\s+|each\s+|all\s+|the\s+)?(.+?)\s+(?:is|are)\s+(?!an?\b|the\b)([A-Za-z][\w-]*)$/i;
+ *  a store" still lands as rdfs:subClassOf, not a property. "was"/"were" join
+ *  "is"/"are" (Tier-5 playtest fix, cycle 3, sibling of Bug A's had->have
+ *  bridge for general-verb facts): "remember that the last commit was risky"
+ *  reads back as a present-tense property fact ("...is risky") the same way a
+ *  general-verb "had" fact already reads back as "has" — properties are
+ *  timeless facts in this store, not tensed events. Safe to widen here
+ *  (unlike the entry gates further up that decide whether `payload` even
+ *  reaches this match at all): this path only runs on an explicit
+ *  "remember/note/…"-WRAPPED sentence, never a bare one, so there's no real
+ *  question-shape ("was X Y?") this could ever misfire on. */
+const TEACH_PROPERTY_RE = /^(?:every\s+|each\s+|all\s+|the\s+)?(.+?)\s+(?:is|are|was|were)\s+(?!an?\b|the\b)([A-Za-z][\w-]*)$/i;
 
 /** The teach lane's provenance tag — mirrors grammar/assert.mjs's provenanceTag
  *  shape under a distinct "teach:" family, so a taught fact is auditable apart
@@ -1351,10 +1461,124 @@ const SOME_A_FEW_RE = /^(some|a few)\s+([\w-]+)\s+are\s+([\w-]+)$/i;
  *  apart from a singular/specific-entity "a"/bare reading (only "every" gets a
  *  recorded quantifier here — this function's OWN caller passes it through to
  *  teachFact; assertTurn, below, records the same "every" quantifier
- *  independently for the pre-existing ACE-success path). Single-token X and Y
- *  only — the same fragment scope parseAce's own copula patterns cover, just
- *  with X's lexicon-membership requirement lifted. */
-const UNKNOWN_SUBJECT_RE = /^(every\s+|each\s+|all\s+|a\s+|an\s+)?([\w-]+)\s+(?:is|are)\s+(?:an?\s+)?([\w-]+)$/i;
+ *  independently for the pre-existing ACE-success path). Y (the object) is a
+ *  single token, same as parseAce's own copula fragments; X (the subject) is
+ *  ONE OR TWO tokens (Tier-5 playtest fix: "vulcan gizmo is a tool"/"remember
+ *  vulcan gizmo is a tool" fell straight to a "teach me" nudge that offered
+ *  THIS EXACT phrasing as the fix, then itself failed when tried — a
+ *  single-token-only subject was too narrow for a natural 2-word noun phrase,
+ *  the same class of gap OWNS_TEACH_RE's own object had before its own
+ *  Tier-5 widening, above). The greedy quantifier tries the longer 2-word
+ *  subject first, backtracking to 1 word only if the tail doesn't then start
+ *  with is/are — the "is/are" anchor immediately after the subject removes
+ *  the ambiguity a fully free-form multi-word subject would otherwise have. */
+const UNKNOWN_SUBJECT_RE = /^(every\s+|each\s+|all\s+|a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:is|are)\s+(?:an?\s+)?([\w-]+)$/i;
+
+/** ISA-family predicates (mirrors the private ISA_PREDICATES set defined near
+ *  memoryFacts, below, at module scope — both are simple top-level consts
+ *  evaluated once at load time, so referencing either from a function defined
+ *  earlier in this file is safe: no function here actually RUNS until well
+ *  after the whole module has finished loading). Named again here, right by
+ *  its one caller, so isGroundedByFact reads standalone. */
+const MINT_ISA_PREDICATES = new Set(["rdfs:subClassOf", "rdf:type"]);
+
+/** Small CLOSED set of generic English root nouns that count as always-
+ *  grounded anchor terms for the mint-fallbacks below (operator refinement,
+ *  2026-07-09) — deliberately NOT added to lexicon-core.json itself (that
+ *  file stays the curated ~180-word CODE vocabulary; these are ordinary-
+ *  English root nouns with no code meaning at all, confirmed absent from it
+ *  today). Their only job is to give a user who hits the "both sides
+ *  ungrounded" decline (groundingSuggestionMiss, below) an honest, guessable
+ *  way in: ground one brand-new term via one of THESE words first ("every
+ *  zorp is a thing"), then chain the other new term off the now-grounded one. */
+const GENERIC_ANCHOR_NOUNS = new Set(["thing", "concept", "object", "entity"]);
+
+/** Shared fact-groundedness primitive (Feature A mint-extension, point 2):
+ *  true when `term` already appears as the SUBJECT or OBJECT of a previously
+ *  taught isa-family fact (rdfs:subClassOf/rdf:type) in memory. A term minted
+ *  by EITHER mint-fallback below (this session, or an earlier one — this
+ *  reads persisted memory, not session-scoped state) is exactly as legitimate
+ *  an anchor for a NEW fact as a static lexicon-core.json word — the whole
+ *  point of this extension is letting new vocabulary compound turn over turn
+ *  ("every cache is a store" mints "store"; "every store is a container" then
+ *  needs "store" to read as known even though it's not in the static lexicon
+ *  at all). Read-only, reuses memoryFacts' plain read path (existence only —
+ *  no trust-ranking needed here) and normFactTerm's own normalization, so a
+ *  fact-grounded term matches under the EXACT spelling teachFact itself stored
+ *  it under. Failure-tolerated: no memory dir / no match → false, never a
+ *  guessed "yes". */
+async function isGroundedByFact(term, memoryDir) {
+  if (!memoryDir) return false;
+  const raw = String(term ?? "").trim();
+  if (!raw) return false;
+  const { normFactTerm } = await import("./memory/core.mjs");
+  const t = normFactTerm(raw);
+  if (!t) return false;
+  // TAUGHT-only (same discipline factReadBack's own cax-sco/scm-sco proof
+  // chase already uses, above, for the identical reason: the bulk background
+  // corpus band (ConceptNet, trust 0.7, seeded by the thousands on a fresh
+  // repo) mentions ordinary English words like "store"/"container" constantly
+  // — treating THOSE as "grounded" would silently reopen the general lexicon
+  // bypass this whole feature is deliberately narrow to avoid. Only what the
+  // OPERATOR actually taught (or a prior `tmct syllogise` entailment) anchors
+  // a term here. factRows (not memoryFacts) is used specifically because it's
+  // the one read path that carries sourceTypes for this filter.
+  const rows = await factRows(memoryDir);
+  const isTaught = (f) => !f.sourceTypes?.includes("corpus") && !f.sourceTypes?.includes("web");
+  return rows.some((f) => MINT_ISA_PREDICATES.has(f.predicate) && isTaught(f) && (f.subject === t || f.object === t));
+}
+
+/** Shared "is this term grounded in ANY sense" aggregate (Feature A mint-
+ *  extension, point 2's named shared helper) — a static lexicon word (any
+ *  part of speech, via `classify`), a GENERIC_ANCHOR_NOUNS root, OR a term
+ *  already anchored by a previously taught isa-family fact (isGroundedByFact,
+ *  above). Used by unknownObjectFallback's subject/object groundedness checks
+ *  below, where no part-of-speech branching follows — just "known or not".
+ *  (unknownSubjectFallback's own object-known check, above/below, stays
+ *  narrower and NOUN-specific — see its own comment — so an object that's
+ *  merely a known ADJECTIVE doesn't get misrouted into the class/subClassOf
+ *  branch instead of the property branch.) */
+async function isGroundedTerm(term, lex, memoryDir) {
+  const raw = String(term ?? "").trim();
+  if (!raw) return false;
+  if (GENERIC_ANCHOR_NOUNS.has(raw.toLowerCase())) return true;
+  const { classify } = await import("./grammar/lexicon.mjs");
+  if (classify(raw, lex)) return true;
+  return isGroundedByFact(raw, memoryDir);
+}
+
+/** The "both sides ungrounded" grounding NUDGE (operator refinement,
+ *  2026-07-09): reuses teachSuggestion's own "compute a hint, APPEND it to
+ *  the existing honest-miss message, never replace/silently guess" pattern
+ *  (see its docblock, above, and the "did"/"why" append-style construction in
+ *  teachLane's own final decline, below) for a DIFFERENT decline case —
+ *  rather than mint a relationship between two brand-new terms (a real
+ *  fabrication risk, unknownObjectFallback's own explicit safety guard,
+ *  below), teachLane's final honest-miss text gets an EXTRA appended nudge
+ *  whenever the declined payload fit the "X is/are Y" shape
+ *  (UNKNOWN_SUBJECT_RE) but NEITHER side is grounded — an honest, actionable
+ *  way in: ground one side via a GENERIC_ANCHOR_NOUNS root first ("every zorp
+ *  is a thing"), then chain the other off the now-grounded term. Deliberately
+ *  APPENDED rather than a replacement/short-circuit: a "both sides
+ *  ungrounded" is/are sentence with a KNOWN subject on one side (e.g. "module
+ *  is banana") never reaches this at all (isGroundedTerm(subject) is true, so
+ *  the very first return below fires) — that stays unknownObjectFallback's
+ *  own mint territory, entirely unaffected here. Returns "" (message
+ *  unchanged) whenever the payload doesn't fit the shape, or at least one
+ *  side IS already grounded — a DIFFERENT, more specific reason it declined,
+ *  where this nudge would be actively unhelpful noise. */
+async function ungroundedPairHint(payload, lexicon, memoryDir) {
+  if (!memoryDir) return "";
+  const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
+  if (!m) return "";
+  const [, , subjectRaw, objectRaw] = m;
+  const { loadLexicon } = await import("./grammar/lexicon.mjs");
+  const lex = lexicon || loadLexicon();
+  if (await isGroundedTerm(subjectRaw, lex, memoryDir)) return "";
+  if (await isGroundedTerm(objectRaw, lex, memoryDir)) return "";
+  return ` I don't know "${subjectRaw}" or "${objectRaw}" yet. Try grounding one first, e.g. `
+    + `"every ${subjectRaw} is a thing", then "every ${objectRaw} is a ${subjectRaw}".`;
+}
 
 /** The unknown-SUBJECT direct-write fallback (point 1 + point 2's bare-property
  *  extension): tried ONLY after the real ACE grammar (assertTurn) has already
@@ -1367,18 +1591,25 @@ const UNKNOWN_SUBJECT_RE = /^(every\s+|each\s+|all\s+|a\s+|an\s+)?([\w-]+)\s+(?:
  *    - X is actually a KNOWN lexicon word — then the ACE grammar's own miss was
  *      a real structural/vocabulary problem elsewhere (e.g. Y itself unknown as
  *      the WRONG part of speech), never silently reinterpreted through this
- *      narrow exception;
- *    - Y resolves as NEITHER a known noun NOR a known adjective — the OBJECT
- *      must still be a term tmct actually knows; an unknown Y stays an honest
- *      miss (never a guess), exactly like the pre-existing "monkey is an
- *      animal" case.
- *  Y resolving as a NOUN writes rdfs:subClassOf (mirrors the ACE grammar's own
- *  subClassOf/typeAssertion pattern); Y resolving as an ADJECTIVE (and not also
- *  a noun) writes mgx:hasProperty (mirrors the wrapped "remember that X is
- *  deprecated" property frame — reused here for the bare/unwrapped form too,
- *  since the free pass is about the SUBJECT, not about the "remember that"
- *  wrapper). Only the "every" determiner records a quantifier (point 3: "a"/
- *  bare/"your" read as one specific entity, not a class-level generalization). */
+ *      narrow exception. (NOTE: this stays a STATIC-lexicon-only check,
+ *      deliberately not widened to isGroundedTerm — a subject that's grounded
+ *      only via a PRIOR taught fact, not the static lexicon, is precisely the
+ *      case unknownObjectFallback, below, owns instead.)
+ *    - Y resolves as NEITHER a known noun NOR a known adjective NOR a term
+ *      already grounded by a prior taught fact / a GENERIC_ANCHOR_NOUNS root
+ *      (Feature A mint-extension, point 2 — a term minted by
+ *      unknownObjectFallback, below, reads exactly as known here as any
+ *      lexicon word) — the OBJECT must still be a term tmct actually knows;
+ *      an unknown Y stays an honest miss (never a guess), exactly like the
+ *      pre-existing "monkey is an animal" case.
+ *  Y resolving as a NOUN (or fact-/anchor-grounded) writes rdfs:subClassOf
+ *  (mirrors the ACE grammar's own subClassOf/typeAssertion pattern); Y
+ *  resolving as an ADJECTIVE (and not also a noun) writes mgx:hasProperty
+ *  (mirrors the wrapped "remember that X is deprecated" property frame —
+ *  reused here for the bare/unwrapped form too, since the free pass is about
+ *  the SUBJECT, not about the "remember that" wrapper). Only the "every"
+ *  determiner records a quantifier (point 3: "a"/bare/"your" read as one
+ *  specific entity, not a class-level generalization). */
 async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
@@ -1389,7 +1620,12 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   // A known X's own ACE miss is a real miss — never silently reinterpreted here.
   if (classify(subjectRaw, lex)) return null;
   const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
-  if (lookupNoun(lex, objectRaw)) {
+  // Point 2 (mint-extension): a PRIOR turn's minted term, or a
+  // GENERIC_ANCHOR_NOUNS root, grounds Y just as legitimately as a static
+  // lexicon noun — both are always treated as class-level (never property),
+  // consistent with unknownObjectFallback (below) always minting a CLASS.
+  if (lookupNoun(lex, objectRaw) || GENERIC_ANCHOR_NOUNS.has(String(objectRaw).toLowerCase())
+    || (await isGroundedByFact(objectRaw, memoryDir))) {
     return teachFact(memoryDir, sessionId, {
       subject: subjectRaw, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
     });
@@ -1404,6 +1640,67 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   return null; // Y unknown too — decline honestly, never guess
 }
 
+/** The unknown-OBJECT mint fallback (Feature A, 2026-07-09 operator-authorized
+ *  vocabulary-growth extension): the MIRROR of unknownSubjectFallback, above —
+ *  same "X is/are Y" payload shape (UNKNOWN_SUBJECT_RE, reused verbatim,
+ *  never a second regex for the identical shape), tried as a SIBLING call
+ *  right after unknownSubjectFallback in teachLane (below), but firing on the
+ *  OPPOSITE asymmetry: SUBJECT already grounded (a real lexicon-core.json
+ *  word of ANY part of speech, a GENERIC_ANCHOR_NOUNS root, OR a term a PRIOR
+ *  turn already minted via either fallback — isGroundedTerm, shared with this
+ *  check) and OBJECT completely ungrounded. Mints the object as a new
+ *  class-level concept (rdfs:subClassOf, same predicate/quantifier machinery
+ *  teachFact/unknownSubjectFallback already use) so ordinary conversation can
+ *  build up new vocabulary turn over turn: "every cache is a store" (subject
+ *  "cache" grounded via the static lexicon) mints "store"; a LATER "every
+ *  store is a container" then finds "store" grounded via the fact just
+ *  minted (not the static lexicon at all) and mints "container" the same way.
+ *
+ *  GATED ON A GENUINE UNIVERSAL QUANTIFIER ("every"/"each"/"all" — never bare/
+ *  "a"/"an"/"your"): minting a NEW CLASS-LEVEL CONCEPT is inherently a general
+ *  claim about a class, the same "every"/bare distinction unknownSubjectFallback's
+ *  own docblock already draws (point 3) between a class generalization and a
+ *  claim about ONE specific entity. This is load-bearing, not cosmetic: a bare
+ *  "module is banana" (a KNOWN lexicon subject, an unrecognized bare object,
+ *  NO determiner at all) is a pinned regression — it must stay a plain honest
+ *  miss, never silently minted — and a WRAPPED "remember that X is <adjective>"
+ *  (also determiner-less at the subject) must keep falling through to
+ *  TEACH_PROPERTY_RE's own, more permissive arbitrary-adjective path
+ *  unimpeded. Requiring the determiner keeps this fallback's mint exactly as
+ *  narrow as the vocabulary-growth feature actually needs (every required
+ *  test case in this feature's own spec phrases the mint sentence with
+ *  "every"), without swallowing either of those pre-existing shapes.
+ *
+ *  The critical safety guard (operator's own stated worry, mirrored from
+ *  unknownSubjectFallback's docblock): this must NEVER silently mint when
+ *  BOTH sides are ungrounded ("every zorp is a florp" — two brand-new,
+ *  never-seen terms with no relation to each other tmct actually knows) —
+ *  declines here (null), and teachLane's own final honest-miss text picks up
+ *  an appended grounding NUDGE for exactly this case (ungroundedPairHint,
+ *  above) — never a silent guess, never a silent hard-swallowed decline
+ *  either. Any OTHER decline (subject ungrounded + object grounded — not this
+ *  fallback's asymmetry; or both grounded — already known, nothing to mint;
+ *  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. */
+async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon }) {
+  if (!memoryDir) return null;
+  const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
+  if (!m) return null;
+  const [, det, subjectRaw, objectRaw] = m;
+  if (!/^(?:every|each|all)$/i.test((det || "").trim())) return null; // class-level mint needs a real universal quantifier
+  const { loadLexicon } = await import("./grammar/lexicon.mjs");
+  const lex = lexicon || loadLexicon();
+  const subjectGrounded = await isGroundedTerm(subjectRaw, lex, memoryDir);
+  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
+  const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
+  return teachFact(memoryDir, sessionId, {
+    subject: subjectRaw, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
+  });
+}
+
 // ---- BUG 3 (2026-07-09, operator-authorized generalizing — "I don't know
 // where that ban came from, overturn it. build it."): general verb-to-
 // predicate teaching. "remember tony has a hat" / "remember margo eats ribs"
@@ -1442,7 +1739,21 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
  *  multi-word subject simply doesn't match here and honestly declines
  *  (point 6) rather than risk a wrong split — the is/are-specific frames
  *  elsewhere in this lane already own that broader territory. */
-const GENERAL_VERB_TEACH_RE = /^([\w'-]+)\s+([a-z]+)\s+(.+?)[.!?]*$/i;
+// Tier-5 playtest fix (this session): a frequency/degree ADVERB commonly sits
+// between a bare-name subject and the real verb in a natural teaching
+// sentence — the operator's own example, "remember that TaskController
+// usually needs review", mis-split subject="TaskController", VERB="usually"
+// (GENERAL_VERB_TEACH_RE had no way to see "usually" wasn't the verb), minting
+// a nonsense mgx:usually predicate and, worse, garbling the confirmation
+// itself: thirdPersonSingularSurface's naive fallback appended "-ies" to the
+// unrecognized lemma, surfacing "taskcontroller usuallies needs review". A
+// closed, non-capturing adverb-skip (never itself eligible to BE the verb)
+// fixes this at the source for both the teach shape and its query-side twins
+// below, without widening what counts as a recognized shape at all — the same
+// "recognition closed, mapping generalized" split this lane already uses.
+const TEACH_ADVERB_SKIP_SRC = "(?:(?:usually|often|sometimes|rarely|never|always|typically|generally|"
+  + "occasionally|frequently|normally|regularly|commonly|mostly|currently|still|also|really|actually)\\s+)?";
+const GENERAL_VERB_TEACH_RE = new RegExp(`^([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+)\\s+(.+?)[.!?]*$`, "i");
 /** Determiners/quantifiers that make the FIRST token an article, not a real
  *  bare-name subject ("every controller…", "the cache…") — GENERAL_VERB_TEACH_RE
  *  would otherwise happily bind them as a 1-token subject and misread the
@@ -1477,13 +1788,23 @@ const GENERAL_VERB_ANYWHERE_EXCLUDE_RE = /\b(?:is|are|am|owns|maintains)\b/i;
  *  documented contract) and this falls back to the verb AS TYPED — still a
  *  perfectly storable/retrievable predicate, just not cross-inflection
  *  canonicalized. Never a hand-curated per-verb table entry required. */
+// Bug A (operator manual-chat find, this session): only the exact raw strings
+// "has"/"have" were special-cased onto HAS_A_PREDICATE above — past tense "had"
+// (or "having") fell through to the generic mgx:<lemma> path, where the lemma of
+// "had" IS "have", and predicatePhrase's thirdPersonSingularSurface fallback
+// naively appends "s" to any unrecognized lemma ending ("have"+"s" = "haves" —
+// wrong; the correct irregular is "has"). Fixed by checking the LEMMA (not just
+// the raw verb) for "have" — this catches had/having/has/have uniformly, so
+// "remember X had soup" reads back "...has soup", never "...haves soup".
 async function generalVerbPredicate(verb) {
   const v = String(verb || "").toLowerCase();
   if (v === "has" || v === "have") return HAS_A_PREDICATE;
   try {
     const { proseLemma } = await import("./prose-nlp.mjs");
     const lemma = proseLemma();
-    return `mgx:${lemma ? lemma(v) : v}`;
+    const l = lemma ? lemma(v) : v;
+    if (l === "have") return HAS_A_PREDICATE;
+    return `mgx:${l}`;
   } catch {
     return `mgx:${v}`;
   }
@@ -1510,6 +1831,35 @@ async function generalVerbTeach(payload) {
   return { subject, predicate, object };
 }
 
+// ---- General verb-to-predicate DIRECT-QUESTION retrieval (item 5, this
+// session's follow-up to the teach mechanism above): "does margo eat ribs" /
+// "did margo eat ribs" / "what does margo eat" against a fact taught via
+// generalVerbTeach. "did" joins "does" so past-tense forms work too (also
+// GROUP 3 Bug B — "what did X have"/"did margo eat ribs"). Wired into
+// factReadBack (below), which only runs on an already-true `miss`, so these
+// never race ask.mjs's closed structural grammar for a real graph query
+// ("does TaskController call widget" resolves there first, this lane is never
+// reached). Both run the SAME GENERAL_VERB_EXCLUDE_RE/GENERAL_VERB_ANYWHERE_
+// EXCLUDE_RE decline guards generalVerbTeach uses, and route the verb through
+// the SAME generalVerbPredicate (not a re-implementation), so the has/have
+// bridge (and Bug A's had/having lemma fix) is automatic on the query side too. ----
+// Same adverb-skip as GENERAL_VERB_TEACH_RE above (TEACH_ADVERB_SKIP_SRC),
+// reused so "does TaskController usually need review"/"what does
+// TaskController usually need" read back a fact taught with the adverb
+// skipped the same way, never mis-splitting "usually" as the verb here either.
+const GENERAL_VERB_YESNO_RE = new RegExp(`^(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+)\\s+(.+?)[?.!\\s]*$`, "i");
+const GENERAL_VERB_OPEN_RE = new RegExp(`^what\\s+(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+)[?.!\\s]*$`, "i");
+/** GENERAL_VERB_EXCLUDE_RE was written for generalVerbTeach's fully-conjugated
+ *  declarative verb ("X OWNS Y", "X MAINTAINS Y") — but "does/did X <verb> Y"
+ *  captures the BARE INFINITIVE after do-support ("does X OWN Y", never "does X
+ *  owns Y"), so "owns"/"maintains" literally never appear in genYN/genOpen's
+ *  captured verb even when the sentence names exactly that relation. Found live
+ *  (a real false "no" against a genuinely-true taught ownership fact, since
+ *  generalVerbPredicate("own") mints a DIFFERENT predicate — mgx:own — than the
+ *  ownership frame's own OWNED_BY_PREDICATE): the query-side guard needs the
+ *  bare-infinitive counterpart too. */
+const GENERAL_VERB_QUERY_EXCLUDE_RE = /^(?:be|own|maintain)$/i;
+
 /** Sentence forms to try asserting for a teach payload: the payload as-is, and
  *  (if it carries no determiner) its "every …" universal — the ACE-OWL shape the
  *  grammar actually lands. */
@@ -1574,7 +1924,14 @@ function teachSuggestion(payload) {
 const TEACH_PRONOUN_RE = /^(?:every\s+|each\s+|all\s+|some\s+|a few\s+|a\s+|an\s+)?(you|i|it|they|he|she|we)\s+\S+/i;
 
 async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
-  const rawInput = String(query).trim();
+  // Tier 6 playtest: this lane read the raw, un-normalized query, so a closed
+  // discourse-marker preamble ahead of a teach sentence ("howdy pardner,
+  // remember that TaskController is fragile") corrupted TEACH_RE's own match —
+  // applyPreambleFrames is idempotent no-op on an already-clean teach sentence
+  // (none of its frames' anchors — greeting/thanks/ack/modal/explain/show-give-me/
+  // topic-switch/hedge — match ordinary teach phrasing, verified against this
+  // lane's own test corpus), so this is purely additive.
+  const rawInput = applyPreambleFrames(String(query).trim());
   const m = rawInput.match(TEACH_RE);
   const wrappedInput = m ? m[1].trim() : null;
   // "your X is a/an Y" (Feature A) — a plain casual synonym for "a/an X is a
@@ -1617,6 +1974,18 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
     });
     if (stored) return stored;
   }
+  // PASSIVE ownership — "<X> is owned by <Name>" (Tier-5 playtest, cycle 2).
+  // Same bare-form gate as the active shape just above: a Capitalized owner
+  // name AND no interrogative lead, so "is TaskController owned by anyone"
+  // (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]))) {
+    const stored = await teachFact(memoryDir, sessionId, {
+      subject: ownPassive[1], predicate: OWNED_BY_PREDICATE, object: ownPassive[2],
+    });
+    if (stored) return stored;
+  }
 
   // "some Xs are Ys" / "a few Xs are Ys" (Feature A) — the plural class-
   // membership quantifier shape. ACE has no quantifier-phrase pattern at all
@@ -1641,6 +2010,33 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
         subject, predicate: SUBCLASS_PREDICATE, object, quantifier,
       });
       if (stored) return stored;
+    } else {
+      // Tier-5 playtest fix (cycle 2), found live: "remember that some
+      // functions are risky" — Y ("risky") is not a lexicon NOUN, so the
+      // subclass path just above correctly declines it (SOME_A_FEW_RE is
+      // subclass-only, by design — "risky" isn't even in the closed
+      // lexicon at all, as either noun or adjective, so gating this decline
+      // on "is Y a known adjective" missed the actual case entirely on the
+      // first attempt at this fix). Without this guard, the sentence fell
+      // through to unknownSubjectFallback/TEACH_PROPERTY_RE below, which DO
+      // tolerate a multi-word subject with NO vocabulary check on the
+      // complement at all — silently mis-teaching the LITERAL 2-word string
+      // "some functions" as if it were one proper-noun subject ("noted —
+      // remembered: some functions is risky", the quantifier word baked
+      // wrongly into the subject and a subject/verb agreement error to
+      // boot), a fact "how many functions are risky" could never sensibly
+      // read back either (HOW_MANY_ARE_RE's own reader only ever looks for
+      // the SUBCLASS_PREDICATE shape this path would have stored, not this
+      // one). A quantified PROPERTY claim isn't a supported shape yet (only
+      // a quantified SUBCLASS claim is) — decline honestly here instead of
+      // silently mis-teaching, rather than let a later, less-specific frame
+      // guess a wrong split.
+      return {
+        text: `I can only remember a quantified fact as "${quantifier} ${someMatch[2]} are <a kind of thing>" (like "${quantifier} bugs are issues") — `
+          + `a quantified claim about a PROPERTY ("${quantifier} ${someMatch[2]} are ${object}") isn't a shape I can store yet. `
+          + `I can remember "${someMatch[2]} are ${object}" for one specific ${subject}, though — try naming it directly.`,
+        via: "teach-miss", miss: true,
+      };
     }
   }
 
@@ -1665,7 +2061,28 @@ 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;
-  if (!payload) return null;
+  if (!payload) {
+    // Tier-5 playtest fix (cycle 3), found live: "remember that every
+    // controller needs review" — a QUANTIFIED subject ("every X", declined
+    // by generalVerbTeach's own GENERAL_VERB_DETERMINER_RE, by design — see
+    // its docblock on the ambiguity risk of a free-form multi-word subject)
+    // combined with a non-copula verb ("needs", not is/are/owns/maintains)
+    // fits NONE of the recognizers above, so `payload` stays null and this
+    // used to return null SILENTLY — the exact "wrong-context wall" bug
+    // class Bug 3's generalVerbTeach mechanism was built to close for
+    // "remember margo eats ribs", re-escaping here through a combination
+    // that mechanism's own deliberate subject-shape restriction doesn't
+    // cover. An explicit "remember/note/…"-wrapped sentence is an
+    // UNAMBIGUOUS teach-intent signal — falling through to the ordinary
+    // structural-query wall is a wrong-context reply even when nothing here
+    // can actually STORE the fact; if `wrapped` stood, keep going with it as
+    // the payload so the residue-detection/final-decline logic below still
+    // runs (never a guess at storing it, just never silence either). A bare,
+    // unwrapped sentence that also fits no shape has no such signal — return
+    // null and let the ordinary cascade decide, unchanged.
+    if (!wrapped) return null;
+    payload = wrapped;
+  }
   // Try to store it (a live session provides the write target). assertTurn returns
   // the "noted — remembered …" confirmation or null (grammar miss / unknown words).
   if (memoryDir) {
@@ -1684,6 +2101,14 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
     // the exact narrowing rules (object must still be known, etc.).
     const fallback = await unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon });
     if (fallback) return fallback;
+    // MIRROR mint fallback (Feature A, 2026-07-09 operator-authorized vocabulary-
+    // growth extension): the known-subject/unknown-object asymmetry — tried
+    // right after the unknown-subject case declines, so a subject the STATIC
+    // lexicon (or a prior taught fact) already grounds can mint a brand-new
+    // object term. See unknownObjectFallback's own docblock for the exact
+    // narrowing rules (the "both sides ungrounded" safety guard, etc.).
+    const objectFallback = await unknownObjectFallback(payload, { memoryDir, sessionId, lexicon });
+    if (objectFallback) return objectFallback;
     // PROPERTY teach — "remember/note that <X> is <adjective>": wrapper-REQUIRED
     // (a bare "X is deprecated" is never silently reified), and only after the
     // ACE grammar declined (unknown words / not the membership shape), so a
@@ -1742,9 +2167,14 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
       + "I can only teach facts using tmct's own code-vocabulary nouns (like module, class, function…), "
       + "not arbitrary new terms."
     : "";
+  // Grounding NUDGE (operator refinement, 2026-07-09): APPENDED, never a
+  // replacement, exactly like "did" above — see ungroundedPairHint's own
+  // docblock for why this is scoped to the "both sides ungrounded, fits the
+  // X is/are Y shape" case only.
+  const groundingHint = await ungroundedPairHint(payload, lexicon, memoryDir);
   return {
     text: `I couldn't store that —${why} I remember facts in the shape "every X is a Y", where X and Y are `
-      + `words I know.${did} Type /memory to see what I already remember.`,
+      + `words I know.${did}${groundingHint} Type /memory to see what I already remember.`,
     via: "teach-miss", miss: true,
   };
 }
@@ -1754,11 +2184,18 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
 // ONLY (the caller gates on a miss) and every pattern is a WHOLE-LINE self/session
 // reference with no graph entity or predicate, so real graph queries ("what does X
 // import", the meta "what does imports mean", "what did i ask before") never match.
-const WHAT_KNOW_RE = /^what\s+(?:do\s+you|d'?you)\s+know(?:\s+so\s+far)?$/;
+// Bug D (operator manual-chat find, this session): "what is in your memory"/
+// "what's in your memory" is a plain synonym of the bare "what do you know" —
+// widened here rather than folded in as "what do you remember" (that phrase is
+// ALREADY WHOLE_RECALL_RE's own, more specific, territory — it lists every
+// remembered fact, a strictly better answer than this lane's short summary; see
+// WHOLE_RECALL_RE's docblock below and the pinned "'what do you remember' ...
+// STILL list facts" test — folding it in here would silently regress that).
+const WHAT_KNOW_RE = /^(?:what\s+(?:do\s+you|d'?you)\s+know(?:\s+so\s+far)?|what(?:'s|s|\s+is)\s+in\s+your\s+memory)$/;
 // 0.8.2 WS4 wall kindness (c): the most likely stranger openers — "what does this
 // app/codebase do", "what is this app (for)" — join the orientation lane, so a
 // first-touch question gets the live overview instead of the grammar wall.
-const META_ORIENT_RE = /^(?:what(?:'s| is| are)?\s+this(?:\s+(?:app|codebase|repo|repository|project|code|thing))?|what\s+(?:codebase|repo|repository|project)\s+is\s+this|what\s+does\s+(?:this|the)\s+(?:app|code|codebase|project|repo)\s+do|what\s+is\s+(?:this|the)\s+app(?:\s+for)?|what\s+am\s+i\s+looking\s+at|what\s+is\s+tmct|how\s+do\s+i\s+(?:start|begin|get\s+started|get\s+going|load\s+(?:my\s+)?code|index\s+(?:my\s+)?(?:code|repo|repository)|use\s+(?:this|you|tmct))|where\s+do\s+i\s+(?:start|begin))$/;
+const META_ORIENT_RE = /^(?:what(?:'s| is| are)?\s+this(?:\s+(?:app|codebase|repo|repository|project|code|thing))?|what\s+(?:codebase|repo|repository|project)\s+is\s+this|what\s+does\s+(?:this|the)\s+(?:app|code|codebase|project|repo)\s+do|what\s+is\s+(?:this|the)\s+app(?:\s+for)?|what\s+am\s+i\s+looking\s+at|what\s+is\s+tmct|how\s+do\s+i\s+(?:start|begin|get\s+started|get\s+going|load\s+(?:my\s+)?code|index\s+(?:my\s+)?(?:code|repo|repository)|use\s+(?:this|you|tmct))|where\s+do\s+i\s+(?:start|begin)|what\s+should\s+i\s+(?:read|look\s+at)\s+first(?:\s+to\s+understand\s+(?:this\s+)?(?:codebase|code|repo|repository|project))?|where\s+should\s+i\s+start\s+reading(?:\s+(?:this\s+)?(?:codebase|code|repo|repository|project))?|where\s+do\s+i\s+begin\s+reading(?:\s+(?:this\s+)?(?:codebase|code|repo|repository|project))?)$/;
 
 /** A SHORT memory summary (never a fact dump) for the bare "what do you know".
  *  This branch only fires when rows.length === 0 — i.e. precisely the case where
@@ -1795,15 +2232,57 @@ async function memorySummary(memoryDir, graph) {
 // case-sensitive, so this reads the ORIGINAL query text, never metaLane's
 // lowercased `q` (authorLane's same discipline, just above/below).
 const MODULE_ORIENT_RE = /^what\s+does\s+(.+?)\s+do\??$/i;
+/** The SUBJECT-FIRST word order of the SAME question ("what saveStore does" vs
+ *  "what does saveStore do") — Tier 6 playtest, §3b surface-variation axis: a
+ *  perfectly natural alternate phrasing of an ALREADY-recognized intent that
+ *  used to hit the raw grammar wall outright (MODULE_ORIENT_RE's own anchor
+ *  requires "does" BEFORE the term). Tried only when MODULE_ORIENT_RE/
+ *  MODULE_PURPOSE_RE both miss; the entity-resolution gate just below (a real,
+ *  UNIQUE graph entity or this lane declines) is what keeps this loose an
+ *  ending safe — a syntactic match against a term that isn't a real entity
+ *  simply falls through unchanged, same as every other lane in this file. */
+const MODULE_ORIENT_SVO_RE = /^what\s+(.+?)\s+does\??$/i;
+// Seonix Batch 3 (3a) — purpose/identity phrasing: "whats X for"/"what's X
+// about"/"what is X for", the sibling of "what does X do" that asks for the
+// SAME module-grain overview. Deliberately does NOT claim the literal noun
+// "app" ("what is this app for") — META_ORIENT_RE (above) already hardcodes
+// that exact phrasing and is checked BEFORE moduleOrientLane runs (metaLane's
+// own ordering), so this regex only ever gets a chance at OTHER resolvable
+// terms. "what(?:'s|s|\s+is)" mirrors PERSONAL_ASSISTANT_NUDGE_RE's own
+// tolerance for the bare "whats" contraction spelling, just below.
+const MODULE_PURPOSE_RE = /^what(?:'s|s|\s+is)\s+(.+?)\s+(?:for|about)\??$/i;
+
+/** A leading politeness/formal-ESL wrapper this lane's own anchored regexes
+ *  otherwise miss entirely (Tier 6 playtest): "please explain what does X do"
+ *  starts with neither "what"/"whats" (MODULE_ORIENT_RE/MODULE_PURPOSE_RE's own
+ *  anchor) nor bare "explain" (normalize.mjs's own EXPLAIN_WRAPPER_RE, which
+ *  requires NOTHING before "explain" — a leading "please" defeats it too), so
+ *  it fell straight to the raw grammar wall. A repeated (please|kindly) plus an
+ *  optional "explain [to me]" — both closed, both optional, so a bare "what
+ *  does X do" is untouched (the whole prefix matches empty). */
+const MODULE_ORIENT_POLITENESS_RE = /^(?:(?:please|kindly)\s+)*(?:explain\s+(?:to\s+me\s+)?)?/i;
 
 /** authorLane's discipline, mirrored: a closed regex + an EXACT, UNIQUE
  *  resolution via resolveEntity, else null — never a guess. Pronoun/self
- *  subjects ("what does it/this do") are META_ORIENT_RE's/isConversational's
- *  territory, not this lane's — declined here so they fall through unchanged. */
+ *  subjects ("what does it/this do", "what's it for") are META_ORIENT_RE's/
+ *  isConversational's territory, not this lane's — declined here so they
+ *  fall through unchanged. */
 async function moduleOrientLane(query, { graph }) {
   if (!graph) return null;
-  const q = String(query).trim().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
-  const m = q.match(MODULE_ORIENT_RE);
+  let q = String(query).trim().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
+  // Tier 6 playtest: this lane reads the ORIGINAL (case-preserving) query text
+  // and never ran any of the general-purpose normalization passes the rest of
+  // the file uses for the SAME class of surface noise — correctMisspellings
+  // for a typo'd anchor word ("waht dose the logger modul do"), applyPreambleFrames
+  // for a topic-switch/self-interruption preamble ("scratch that, what does X
+  // do") — plus a lane-local politeness strip for "please explain X" (applyPreambleFrames's
+  // own EXPLAIN_WRAPPER_RE requires the string to literally START with "explain",
+  // so a LEADING "please"/"kindly" ahead of it defeats that frame; see
+  // MODULE_ORIENT_POLITENESS_RE's own docblock). All three are additive,
+  // closed-set, and idempotent on an already-clean query, so applying them here
+  // only ever WIDENS what resolves, never narrows it.
+  q = applyPreambleFrames(correctMisspellings(q)).replace(MODULE_ORIENT_POLITENESS_RE, "");
+  const m = q.match(MODULE_ORIENT_RE) || q.match(MODULE_PURPOSE_RE) || q.match(MODULE_ORIENT_SVO_RE);
   if (!m) return null;
   const term = m[1].trim();
   if (/^(?:it|this|that|they|them)$/i.test(term)) return null;
@@ -2179,7 +2658,11 @@ function configFor(repoPath) {
 /** 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
- *  records fewer ids / does not update the focus, never a crash or a wrong id. */
+ *  records fewer ids / does not update the focus, never a crash or a wrong id.
+ *  The leading-article-strip + trailing-grain-word disambiguation ("the logger
+ *  module" -> Module-only "logger") lives centrally in resolveObject itself
+ *  (ask.mjs) so every direct caller of resolveObject (ask()'s own WHERE/describe
+ *  grammar, traverse(), etc.) gets it too, not just this wrapper. */
 async function resolveEntity(graph, term) {
   if (!graph || !term) return null;
   try {
@@ -2398,6 +2881,13 @@ const FACT_PREDICATE_PHRASES = {
  *  renders verbatim, unchanged from before this fix. */
 function thirdPersonSingularSurface(lemma) {
   const w = String(lemma || "");
+  // Bug A safety net: "have" should never reach this naive fallback at all
+  // (generalVerbPredicate special-cases it onto mgx:hasA before a predicate is
+  // ever minted), but if some OTHER path ever reaches here with it as typed —
+  // e.g. wink-nlp unavailable so lemma degrades to the raw verb — the naive
+  // "+s" rule would produce the wrong-MEANING "haves" instead of the correct
+  // irregular "has".
+  if (/^have$/i.test(w)) return "has";
   if (/[a-z]y$/i.test(w) && !/[aeiou]y$/i.test(w)) return `${w.slice(0, -1)}ies`;
   if (/(?:s|x|z|ch|sh|o)$/i.test(w)) return `${w}es`;
   return `${w}s`;
@@ -2523,6 +3013,25 @@ function factTermVariants(normFactTerm, term) {
   return v;
 }
 
+/** 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
+ *  and IS_ADJECTIVE_YESNO_RE's property yes/no reader use (below): a bare
+ *  length >= 4 floor alone isn't enough, since "module" (6 chars) is shared
+ *  by "logger module" AND "validate module" and any OTHER "X module" taught
+ *  subject — without this exclusion, "is the validate module deprecated"
+ *  confidently answered YES off a fact taught for "logger module" (found
+ *  live, Tier-5 playtest cycle 5 — a real false-positive fabrication, not a
+ *  routing gap, caught before shipping). Mirrors RECALL_STOPWORDS' own
+ *  path-noise exclusion (src/lib/mjs never counting as a real overlap
+ *  either) — same principle, a different word class. */
+const GENERIC_ENTITY_WORDS = new Set([
+  "module", "modules", "class", "classes", "function", "functions",
+  "method", "methods", "handler", "handlers", "controller", "controllers",
+  "service", "services", "component", "components", "flow", "flows",
+  "thing", "things", "item", "items", "object", "objects", "commit", "commits",
+]);
+
 // ---- PLAN_ontology-hierarchies.md §3 tracks (a)+(b): synonymsOf(term) —
 // QUERY-TIME term expansion wiring the two already-parsed-but-inert synonym
 // resources. §1's "two vocabulary gates" distinction: this widens what a
@@ -2605,8 +3114,14 @@ async function synonymsOf(term) {
  *  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"]);
-/** "what do you know about caches" — the open recall-everything form. */
-const KNOW_ABOUT_RE = /^what\s+do\s+you\s+know\s+about\s+(.+?)[?.!\s]*$/i;
+/** "what do you know about caches" — the open recall-everything form. Bug E
+ *  (operator manual-chat find, this session) widened this to also accept
+ *  "what is in your memory about X" / "what's in your memory about X" / "what
+ *  do you remember about X" as plain synonyms — none of these collide with an
+ *  existing more-specific lane (TOLD_ABOUT_RE only owns "what did i tell you
+ *  about X"; WHOLE_RECALL_RE's own "what do you remember" has no "about X"
+ *  tail, so it's a disjoint shape). */
+const KNOW_ABOUT_RE = /^(?:what\s+do\s+you\s+know\s+about|what(?:'s|s|\s+is)\s+in\s+your\s+memory\s+about|what\s+do\s+you\s+remember\s+about)\s+(.+?)[?.!\s]*$/i;
 /** How many facts a single answer lists before the remainder is paged with "more". */
 const FACT_ANSWER_CAP = 32;
 
@@ -2631,7 +3146,11 @@ async function factAnswer(memoryDir, query, envelope, miss) {
   if (!metaTerm && miss && !envelope?.parsed) {
     const m = q.match(BARE_WHATIS_RE)
       || q.match(/^what\s+(?:does|do)\s+(.+?)\s+means?[?.!\s]*$/i);
-    if (m) metaTerm = m[1];
+    // Seonix Batch 2 Fix 3: strip a curated trailing scope clause ("… in this
+    // graph"/"… in this codebase"/…) the same way grammar.mjs's T5 and
+    // metaTermOf do — BARE_WHATIS_RE's capture is otherwise the literal glued
+    // tail, verbatim.
+    if (m) metaTerm = stripTrailingScopeFiller(m[1]);
   }
   if (metaTerm) {
     // BUG 1 fix: "what is a tree used for" parses (grammar.mjs T5) to the
@@ -2682,15 +3201,93 @@ async function factAnswer(memoryDir, query, envelope, miss) {
   const know = q.match(KNOW_ABOUT_RE);
   if (know) {
     const variants = factTermVariants(normFactTerm, know[1]);
-    const hits = (await memoryFacts(memoryDir)).filter((f) => variants.has(f.subject) || variants.has(f.object));
+    const rows = await memoryFacts(memoryDir);
+    // Bug E subtype walk (operator follow-up request, this session): a
+    // cycle-safe BFS DOWNWARD over isa-family facts from the term's own
+    // variants — every fact whose OBJECT is in the current frontier
+    // contributes its SUBJECT as a known SUBTYPE (and the next hop's
+    // frontier), so "every widget is a component" + "button is a widget" +
+    // "button has a blue-color" lets "what do you know about component"
+    // surface the button fact too, even though "button" never literally
+    // mentions "component". Capped at 8 hops — this is a listing operation,
+    // not findIsaChain's strict maxHops:2 proof-chase, but still bounded as a
+    // safety net against pathological data.
+    //
+    // The chain itself is walked over TAUGHT isa facts only (same "isTaught"
+    // discipline the live cax-sco/scm-sco proof chase already uses, below) —
+    // the bulk background corpus (thousands of ConceptNet/seon "is a kind of"
+    // rows) would otherwise chain almost ANY term into hundreds of coincidental
+    // "subtypes" that have nothing to do with what the OPERATOR actually
+    // taught, drowning the real answer and defeating the negative-case
+    // discipline this feature exists to preserve. The literal-mention hits
+    // (the ORIGINAL, non-subtype half of the filter below) still include
+    // corpus facts exactly as before — only the SUBTYPE DISCOVERY chain is
+    // taught-only.
+    // `rows` here is memoryFacts()'s plain {subject,predicate,object,provenance}
+    // shape (no `sourceTypes` — that's factRows()'s own trust-enriched shape),
+    // so the taught/corpus distinction reads the SAME provenance-string
+    // convention renderFactLine already keys its own corpus-vs-taught framing
+    // on, just above.
+    const isTaughtFact = (f) => !String(f.provenance || "").includes("corpus:") && !String(f.provenance || "").includes("web:");
+    const isaRows = rows.filter((f) => ISA_PREDICATES.has(f.predicate) && isTaughtFact(f));
+    const subtypeSubjects = new Set();
+    let frontier = variants;
+    for (let hop = 0; hop < 8 && frontier.size; hop += 1) {
+      const nextSubjects = new Set();
+      for (const f of isaRows) {
+        if (frontier.has(f.object) && !subtypeSubjects.has(f.subject)) nextSubjects.add(f.subject);
+      }
+      if (!nextSubjects.size) break;
+      for (const s of nextSubjects) subtypeSubjects.add(s);
+      const nextFrontier = new Set();
+      for (const s of nextSubjects) for (const v of factTermVariants(normFactTerm, s)) nextFrontier.add(v);
+      frontier = nextFrontier;
+    }
+    let hits = rows.filter((f) => variants.has(f.subject) || variants.has(f.object) || subtypeSubjects.has(f.subject));
+    // Tier-5 playtest fallback: a taught fact's subject is often a real NOUN
+    // PHRASE ("logger module", "tasks handler"), but a natural follow-up
+    // shortens it to one head word ("what do you know about the logger") —
+    // an exact-variant miss above, since "logger" !== "logger module". Only
+    // tried when the exact/subtype pass found NOTHING (never overrides a real
+    // hit), and only on a whole WORD (length >= 4, the same floor
+    // resolveObject's own tier-3/5 containment checks use to keep a short
+    // staccato word from hijacking an unrelated fact) shared between the
+    // query term and a fact's subject/object — a listing/discovery feature
+    // (like the subtype walk above), not a yes/no claim, so a slightly wider
+    // recall net is consistent with this lane's existing inclusiveness.
+    if (!hits.length) {
+      const queryWords = normFactTerm(know[1]).split(/\s+/).filter((w) => w.length >= 4 && !GENERIC_ENTITY_WORDS.has(w));
+      if (queryWords.length) {
+        const wordsOf = (s) => new Set(String(s || "").split(/\s+/));
+        const overlaps = (term) => { const w = wordsOf(term); return queryWords.some((qw) => w.has(qw)); };
+        hits = rows.filter((f) => overlaps(f.subject) || overlaps(f.object));
+      }
+    }
+    // A genuinely empty result here is a real miss (Tier-5 playtest cycle 3:
+    // "what do you know about the last commit" needs a TEACH-OFFER, not a
+    // bare wall — added as a LATE runTurn-level addition, below, alongside
+    // the sibling "what is X" offer, rather than returned from here: an
+    // early return through this function's normal contract would pre-empt
+    // runTurn's own wall-shortening pass (shortMissHint/lane 5), leaving the
+    // FULL unshortened grammar cheat-sheet standing under the offer instead
+    // of the nicer tailored one-liner — found live while adding this fix).
     if (!hits.length) return null;
     // echo the STORED spelling ("caches" asked → "cache" known), never a guess
-    const term = variants.has(hits[0].subject) ? hits[0].subject : hits[0].object;
+    const literalHit = hits.find((f) => variants.has(f.subject) || variants.has(f.object));
+    const term = literalHit
+      ? (variants.has(literalHit.subject) ? literalHit.subject : literalHit.object)
+      : know[1].trim();
+    // when a subtype-derived hit contributed something a plain literal-mention
+    // match wouldn't have found, say so — lets the reader tell subtype-derived
+    // facts apart from literal mentions.
+    const viaSubtype = hits.some((f) => subtypeSubjects.has(f.subject) && !variants.has(f.subject) && !variants.has(f.object));
     const lines = hits.map((f) => `  ${renderFactLine(f)}`);
     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: `${hits.length} remembered fact${hits.length === 1 ? "" : "s"} about ${term}:\n${shown.join("\n")}${extra}`, replace: true, ...(rest.length ? { pending: { items: rest.map((l) => l.trim()), noun: "facts" } } : {}) };
+    const header = `${hits.length} remembered fact${hits.length === 1 ? "" : "s"} about ${term}`
+      + `${viaSubtype ? " (including its known subtypes)" : ""}:`;
+    return { text: `${header}\n${shown.join("\n")}${extra}`, replace: true, ...(rest.length ? { pending: { items: rest.map((l) => l.trim()), noun: "facts" } } : {}) };
   }
   return null;
 }
@@ -2816,6 +3413,45 @@ const KIND_OF_RE = /^what\s+kind\s+of\s+(?:thing|class|type|category|entity)?\s*
 /** "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;
+/** "does/did <Name> own/maintain <X>" — the yes/no ownership claim over the
+ *  SAME mgx:ownedBy facts WHO_OWNS_RE reads (Tier-5 playtest fix). The bare
+ *  infinitive after do-support ("does X own Y", never "does X owns Y") mirrors
+ *  GENERAL_VERB_YESNO_RE's own do-support convention. */
+const OWNS_YESNO_RE = /^(?:does|did)\s+([\w'-]+)\s+(?:owns?|maintains?)\s+(.+?)[?.!\s]*$/i;
+/** "is/are/was/were <X> owned by <Name>" — the PASSIVE yes/no ownership
+ *  claim, sibling of OWNS_YESNO_RE just above and OWNS_PASSIVE_TEACH_RE
+ *  (chat.mjs's teach lane) — same mgx:ownedBy facts, matched BEFORE
+ *  IS_ADJECTIVE_YESNO_RE below (which would otherwise also match this shape,
+ *  backtracking "owned by" into its own subject capture and "<Name>" into its
+ *  adjective slot, silently declining rather than answering). */
+const OWNS_PASSIVE_YESNO_RE = /^(?:is|are|was|were)\s+(.+?)\s+owned\s+by\s+([A-Za-z][\w'-]*(?:\s+[A-Z][\w'-]*)?)[?.!\s]*$/i;
+/** "is/are/was/were <X> <adjective>" — a yes/no claim over a taught
+ *  mgx:hasProperty fact (Tier-5 playtest fix). Deliberately has NO marker
+ *  between subject and complement — "a"/"an"/"a kind of"/"a type of" is
+ *  ISA_ASK_RE's own mandatory territory just below (matched and handled, or
+ *  matched-and-declined, BEFORE this code ever runs), so a genuine "is a
+ *  module a component" is never reachable here. Anaphoric "it"/"this"/"that"
+ *  resolves against the session's current FOCUS (threaded in as `focusLabel`)
+ *  — never a guess when there's no standing focus. Only ever answers "yes"
+ *  (a real fact found) or DECLINES (null) — never a fabricated closed-world
+ *  "no", unlike its ownership/general-verb siblings above: a bare copula
+ *  ("is this good", "is it done") is the single most common CASUAL English
+ *  shape, so a wrong-feeling "no — no remembered fact says X is Y" for
+ *  ordinary small talk would be worse than deferring to the ordinary
+ *  cascade/orientation nudge that already handles it. */
+const IS_ADJECTIVE_YESNO_RE = /^(?:is|are|was|were)\s+(.+?)\s+([A-Za-z][\w-]*)[?.!\s]*$/i;
+const IS_ADJECTIVE_PRONOUN_RE = /^(?:it|this|that)$/i;
+/** The TEACH-OFFER for a subject IS_ADJECTIVE_YESNO_RE resolved but has no
+ *  fact about at all (Tier-5 playtest, cycle 2) — the offered "remember that
+ *  X is Y" phrasing is verified in-state: TEACH_PROPERTY_RE's own subject
+ *  capture is unbounded multi-word with no lexicon gate on the complement, so
+ *  this always actually stores, unlike the bare unwrapped form (which only
+ *  reaches TEACH_PROPERTY_RE via BARE_DECLARATIVE_RE's single-token-subject
+ *  restriction and would fail here). */
+const unknownAdjectiveOffer = (subject, adjective) => ({
+  text: `I don't know anything about "${subject}" yet — teach me directly, e.g. "remember that ${subject.toLowerCase()} is ${adjective}".`,
+  replace: true,
+});
 /** WHOLE-STORE recall (CHATBENCH_006 lever 3): "what did i tell you [last time]",
  *  "what facts do you know", "what do you remember" — list EVERY remembered fact
  *  (no subject/object term to filter on), cited, higher-trust first. The multi-turn
@@ -2881,13 +3517,80 @@ function inheritsChain(graph, startId) {
  *        "what kind of thing is an X" reports X's own type (subject-side first).
  *  Miss-only and run AFTER factAnswer returns null, so it never shadows the
  *  subject-side answer or a schema hit. Returns { text, replace:true } or null. */
-async function factReadBack(memoryDir, query, envelope, miss, graph = null) {
+async function factReadBack(memoryDir, query, envelope, miss, graph = null, focusLabel = null) {
   if (!miss) return null;
   let normFactTerm;
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
   const q = String(query).trim();
+  // 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
+  // IS_ADJECTIVE_YESNO_RE/OWNS_YESNO_RE/OWNS_PASSIVE_YESNO_RE's own anchored
+  // "is|are|was|were|does|did" openers — this session's own three new yes/no
+  // readers, so scoped narrowly to just them (qHedge), not the older
+  // ISA_ASK_RE/WHO_OWNS_RE paths above, which already work without it and
+  // don't need the extra risk of a behavior change. Full leading-connective
+  // tolerance (and/also/so/…) is STACCATO_LEAKED_CONNECTIVES' own separate,
+  // broader territory elsewhere in this file — this is a narrower, adjacent
+  // closed set (hedge adverbs, not coordinators).
+  // "yeah nah" (Tier 6 playtest, §3b dialect axis): the same AU/NZ discourse
+  // opener chat.mjs's own GREET closed set and GREETING_PREAMBLE_RE already
+  // recognize elsewhere, added here too — "yeah nah, is TaskController
+  // fragile" is the SAME one-word-out-of-alignment problem the hedge adverbs
+  // above were fixed for, just a dialect opener instead of a hedge adverb.
+  const qHedge = q.replace(/^(?:actually|really|honestly|yeah\s+nah)\s*,?\s+/i, "");
   const rows = await factRows(memoryDir);
-  if (!rows.length) return null;
+  if (!rows.length) {
+    // Tier-5 playtest fix (cycle 2), found live: with TRULY zero facts
+    // remembered yet (a fresh session, nothing taught at all), the early
+    // bail-out below skipped even IS_ADJECTIVE_YESNO_RE's own "subject
+    // completely unknown" TEACH-OFFER further down in this function — "is
+    // the checkout flow deprecated" as someone's genuinely FIRST question
+    // fell to the raw structural wall, unguided. Special-cased here (ahead
+    // of the general empty-memory bail-out every other lane in this function
+    // still relies on) rather than removing the bail-out outright.
+    //
+    // IS_ADJECTIVE_YESNO_RE's own backtracking (no vocabulary restriction on
+    // either capture) means it ALSO syntactically matches shapes that are
+    // NOT a property claim at all — "is a zebra a mammal" (ISA_ASK_RE's own
+    // territory, tried first in the non-empty-rows path below, so never
+    // reached here) and "is there anything bigger" (an existence/staccato-
+    // comparative shape a LATER lane elsewhere in runTurn owns and answers
+    // better than a teach-offer ever could) both regressed real, pinned
+    // tests on first attempt at this fix — caught by running the full suite,
+    // not just the live playtest transcript. Excluded explicitly: ISA_ASK_RE
+    // matches take the SAME priority here they get in the non-empty-rows
+    // path below, and a leading "there" is existential, never a real named
+    // subject a property claim would name.
+    if (!ISA_ASK_RE.test(qHedge)) {
+      const emptyIsAdj = qHedge.match(IS_ADJECTIVE_YESNO_RE);
+      if (emptyIsAdj) {
+        const rawSubject = emptyIsAdj[1].trim();
+        const subject = IS_ADJECTIVE_PRONOUN_RE.test(rawSubject) ? (focusLabel || null) : rawSubject;
+        // Tier 6 playtest: "is logger tested"/"is the store module tested" —
+        // IS_ADJECTIVE_YESNO_RE's own unrestricted backtracking (already flagged
+        // as a recurring risk, see this branch's own docblock above for the
+        // ISA_ASK_RE/"is there" exclusions found the SAME way) ALSO matches
+        // "tested" as if it were a free-form property adjective — but "tested"/
+        // "covered"/"untested"/"uncovered" are REAL structural relation words
+        // (PASSIVE_PARTICIPLE_TO_KIND/QUALIFIERS, ask-vocab.mjs) with an actual
+        // graph-computable meaning ask()'s own grammar already resolved
+        // (envelope.parsed stands — a genuine "tests" reverse-relation
+        // traversal, hit or honest empty). Offering "I don't know that yet —
+        // teach me" here would silently DISCARD a real, honest structural
+        // answer in favor of an irrelevant memory teach-offer — the opposite
+        // failure from every other exclusion in this function (a wrong
+        // OVER-eager offer, not a missed one). Declines only when a real parse
+        // already stood; "is the checkout flow deprecated" (this branch's own
+        // ORIGINAL T8 target — "deprecated" has no structural meaning at all)
+        // has no envelope.parsed to defer to, so it is untouched.
+        if (subject && !/^there\b/i.test(subject) && !envelope?.parsed) {
+          return unknownAdjectiveOffer(subject, emptyIsAdj[2].trim().toLowerCase());
+        }
+      }
+    }
+    return null;
+  }
   const isa = rows.filter((f) => ISA_PREDICATES.has(f.predicate));
   const byTrust = (a, b) => b.trust - a.trust;
   const renderMany = (hits) => {
@@ -2993,6 +3696,181 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null) {
     return renderMany(hits);
   }
 
+  // (a2b) OWNERSHIP yes/no — "does/did <Name> own/maintain <X>": Tier-5
+  // playtest fix, found live — WHO_OWNS_RE only ever answered the OPEN "who
+  // owns X" form; a direct yes/no claim about a specific (owner, thing) pair
+  // ("does margo maintain the tasks handler") fell all the way through to the
+  // structural code-graph wall, even right after teaching exactly that fact,
+  // because GENERAL_VERB_QUERY_EXCLUDE_RE deliberately stands the general-verb
+  // reader down for "own"/"maintain" (they mint a DIFFERENT predicate,
+  // mgx:own/mgx:maintain, than this frame's own OWNED_BY_PREDICATE) — this is
+  // that missing specific reader. Same closed-world convention as (a3)'s
+  // general-verb yes/no just below: a hit answers "yes", no stored fact
+  // answers a definite "no" (never a guessed owner name, unlike the OPEN "who
+  // owns" form above, which stays an honest miss rather than guess WHO).
+  const ownsYN = qHedge.match(OWNS_YESNO_RE);
+  if (ownsYN) {
+    const [, ownerRaw, thingRaw] = ownsYN;
+    const ownerVariants = factTermVariants(normFactTerm, ownerRaw.trim());
+    const thingVariants = factTermVariants(normFactTerm, thingRaw.replace(/^an?\s+/i, "").trim());
+    const hit = rows
+      .filter((f) => f.predicate === OWNED_BY_PREDICATE && thingVariants.has(f.subject) && ownerVariants.has(f.object))
+      .sort(byTrust)[0];
+    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    return {
+      text: `no — no remembered fact says ${ownerRaw.trim().toLowerCase()} owns/maintains ${thingRaw.trim()}.`,
+      replace: true,
+    };
+  }
+
+  // (a2b-ii) PASSIVE ownership yes/no — "is/are/was/were <X> owned by <Name>"
+  // (Tier-5 playtest, cycle 2): same OWNED_BY_PREDICATE facts as (a2b) above,
+  // just the passive phrasing — "is TaskController owned by sam" found live
+  // to WALL entirely (no recognizer at all, teach OR read, for the passive
+  // shape) even right after teaching that exact fact via OWNS_PASSIVE_TEACH_RE.
+  // Checked BEFORE (a2c)'s adjective reader, which would otherwise also match
+  // this shape (backtracking "owned by" into its subject and the owner name
+  // into its adjective slot) and silently decline instead of answering.
+  const ownsPassiveYN = qHedge.match(OWNS_PASSIVE_YESNO_RE);
+  if (ownsPassiveYN) {
+    const [, thingRaw, ownerRaw] = ownsPassiveYN;
+    const thingVariants = factTermVariants(normFactTerm, thingRaw.replace(/^an?\s+/i, "").trim());
+    const ownerVariants = factTermVariants(normFactTerm, ownerRaw.trim());
+    const hit = rows
+      .filter((f) => f.predicate === OWNED_BY_PREDICATE && thingVariants.has(f.subject) && ownerVariants.has(f.object))
+      .sort(byTrust)[0];
+    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    return {
+      text: `no — no remembered fact says ${thingRaw.trim().toLowerCase()} is owned by ${ownerRaw.trim()}.`,
+      replace: true,
+    };
+  }
+
+  // (a2c) PROPERTY yes/no — "is/are/was/were <X> <adjective>": Tier-5 playtest
+  // fix, found live — "remember that the logger module is deprecated" taught a
+  // real mgx:hasProperty fact, but there was no direct-question reader for it
+  // AT ALL (only presuppositionNudge's own narrow "why does X still Y" embeds
+  // this same check) — "is the logger deprecated" fell straight to the
+  // structural wall. Checks BOTH shapes a taught "<X> is <adjective>" can land
+  // as (mirrors presuppositionNudge's own dual check, above): the teach lane's
+  // mgx:hasProperty fact, or — when the adjective is a known ACE-OWL lexicon
+  // data-property word — the ACE grammar's own tmct:<adjective> "true" triple.
+  // "it"/"this"/"that" resolve against `focusLabel` — a bare pronoun with no
+  // standing focus declines (null), same discipline STACCATO_PRONOUN_RE uses.
+  const isAdj = qHedge.match(IS_ADJECTIVE_YESNO_RE);
+  if (isAdj) {
+    const rawSubject = isAdj[1].trim();
+    const subject = IS_ADJECTIVE_PRONOUN_RE.test(rawSubject) ? (focusLabel || null) : rawSubject;
+    const adjective = isAdj[2].trim().toLowerCase();
+    if (subject) {
+      const subjVariants = factTermVariants(normFactTerm, subject);
+      const propertyMatch = (f) => (f.predicate === HAS_PROPERTY_PREDICATE && normFactTerm(f.object) === adjective)
+        || (f.predicate === `tmct:${adjective}` && f.object === "true");
+      // Same head-word fallback as factAnswer's "(c) what do you know about"
+      // lane: a taught subject is often a real noun PHRASE ("logger module"),
+      // shortened in the natural follow-up ("is the logger deprecated") — an
+      // exact-variant miss on its own, on a whole word (length >= 4, the same
+      // floor used elsewhere) shared between the query subject and the fact's
+      // own subject.
+      const subjWords = normFactTerm(subject).split(/\s+/).filter((w) => w.length >= 4 && !GENERIC_ENTITY_WORDS.has(w));
+      const wordOverlap = (f) => subjWords.some((w) => new Set(String(f.subject || "").split(/\s+/)).has(w));
+      const subjectMatch = (f) => subjVariants.has(f.subject) || (subjWords.length && wordOverlap(f));
+      const hit = rows.filter((f) => subjectMatch(f) && propertyMatch(f)).sort(byTrust)[0];
+      if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+      // no hit on THIS property — never a guessed "no" (see
+      // IS_ADJECTIVE_YESNO_RE's own docblock for why this stays silent on a
+      // truth claim, unlike its ownership/general-verb siblings above). But a
+      // subject we DO know something else about ("the logger" has a
+      // deprecated-fact, just not a fast-fact) still deserves an honest, named
+      // receipt — never a bare wall — mirroring factAnswer's own established
+      // convention for a known-subject/wrong-predicate miss ("I don't have
+      // any 'X' facts about Y"). The SAME subjectMatch (exact-variant OR
+      // head-word overlap) decides "known", so a shortened/article-led
+      // subject that found its fact via the overlap fallback is recognized
+      // as known too. A subject with NO known facts at all falls through
+      // undecided — there's nothing honest to say beyond the ordinary
+      // cascade's own miss/orientation nudge.
+      //
+      // Tier 6 playtest: gated on `!envelope?.parsed`, the SAME guard this
+      // function's empty-memory branch above just added, for the identical
+      // reason — "is the logger tested" (after teaching an UNRELATED
+      // "logger... is deprecated" fact) used to return "I don't have a fact
+      // saying the logger is tested" here, discarding a REAL structural
+      // answer ("No tests cover logger") for a word ("tested") that already
+      // has genuine graph-computable meaning. A subject with a KNOWN taught
+      // fact under some OTHER, non-structural property (the common,
+      // originally-intended case here) still gets this receipt exactly as
+      // before, since envelope.parsed is null for those adjectives.
+      if (rows.some(subjectMatch) && !envelope?.parsed) {
+        return { text: `I don't have a fact saying ${subject.toLowerCase()} is ${adjective}.`, replace: true };
+      }
+      // Tier-5 playtest fix (cycle 2), found live: "is the checkout flow
+      // deprecated" as a genuinely FIRST-EVER question about a subject tmct
+      // has never heard of (no fact at all, not even under a different
+      // property) fell through to the raw structural wall, unguided — the
+      // exact "honest 'I don't know that yet' offers to learn" case
+      // SKILL_CHAT_PLAYTEST.md's Tier 5 (§3) itself names. The offered
+      // phrasing is the SAME verified "remember that X is Y" wrapped form
+      // TEACH_PROPERTY_RE actually accepts (arbitrary-length subject, no
+      // lexicon gate on the complement) — never the bare unwrapped form,
+      // which TEACH_PROPERTY_RE only reaches via BARE_DECLARATIVE_RE's own
+      // single-token-subject restriction and would fail for a multi-word
+      // subject like this one. Same helper (unknownAdjectiveOffer) the
+      // empty-memory special-case above this function's own rows.length
+      // bail-out reuses, so the two paths can never disagree on wording.
+      //
+      // Tier 6 playtest: same `!envelope?.parsed` guard as just above — a
+      // subject known only under an UNRELATED property (e.g. "deprecated")
+      // must not offer to teach "tested" when ask()'s own grammar already
+      // resolved it structurally.
+      if (!envelope?.parsed) return unknownAdjectiveOffer(subject, adjective);
+    }
+  }
+
+  // (a3) GENERAL VERB-TO-PREDICATE direct-question retrieval (item 5, this
+  // session): a taught general-verb fact ("margo eats ribs") answered back
+  // directly. Yes/no form matches the taught triple EXACTLY (subject +
+  // predicate + object, via the SAME factTermVariants/normFactTerm matching
+  // WHO_OWNS_RE just used above) — no match is an honest, closed-world "no",
+  // never a guess. Open form lists every stored fact row for {subject,
+  // predicate} regardless of object.
+  const genYN = q.match(GENERAL_VERB_YESNO_RE);
+  if (genYN && !GENERAL_VERB_ANYWHERE_EXCLUDE_RE.test(q)) {
+    const [, subjectRaw, verbRaw, objectRaw] = genYN;
+    const verb = verbRaw.toLowerCase();
+    if (!GENERAL_VERB_EXCLUDE_RE.test(verb) && !GENERAL_VERB_QUERY_EXCLUDE_RE.test(verb)) {
+      const subject = subjectRaw.trim();
+      const object = objectRaw.replace(/^an?\s+/i, "").trim();
+      if (subject && object) {
+        const predicate = await generalVerbPredicate(verb);
+        const subjVariants = factTermVariants(normFactTerm, subject);
+        const objVariants = factTermVariants(normFactTerm, object);
+        const hit = rows
+          .filter((f) => f.predicate === predicate && subjVariants.has(f.subject) && objVariants.has(f.object))
+          .sort(byTrust)[0];
+        if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true, generalVerbQuery: true };
+        return {
+          text: `no — no remembered fact says ${subject.toLowerCase()} ${predicatePhrase(predicate)} ${object}.`,
+          replace: true, generalVerbQuery: true,
+        };
+      }
+    }
+  }
+  const genOpen = q.match(GENERAL_VERB_OPEN_RE);
+  if (genOpen && !GENERAL_VERB_ANYWHERE_EXCLUDE_RE.test(q)) {
+    const [, subjectRaw, verbRaw] = genOpen;
+    const verb = verbRaw.toLowerCase();
+    if (!GENERAL_VERB_EXCLUDE_RE.test(verb) && !GENERAL_VERB_QUERY_EXCLUDE_RE.test(verb)) {
+      const subject = subjectRaw.trim();
+      if (subject) {
+        const predicate = await generalVerbPredicate(verb);
+        const subjVariants = factTermVariants(normFactTerm, subject);
+        const hits = rows.filter((f) => f.predicate === predicate && subjVariants.has(f.subject)).sort(byTrust);
+        if (hits.length) return { ...renderMany(hits), generalVerbQuery: true };
+      }
+    }
+  }
+
   // (b) RECALL — "what did i tell you about X": every remembered fact mentioning X.
   const told = q.match(TOLD_ABOUT_RE);
   if (told) {
@@ -3326,14 +4204,42 @@ const BARE_WHATIS_RE = /^what\s+(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
  *  question asks about — from the parse when present, else recognized directly
  *  via BARE_WHATIS_RE (article optional — see its own docblock for why that's
  *  safe here even though the grammar's own T5 keeps the article mandatory).
- *  Null when the line isn't such a form. */
+ *  Null when the line isn't such a form. Seonix Batch 2 Fix 3: a curated trailing
+ *  scope clause ("what is a Module in this graph") is stripped off the captured
+ *  term the same way grammar.mjs's T5 does (stripTrailingScopeFiller,
+ *  ask-vocab.mjs) — the envelope.parsed.object branch above already carries a
+ *  trimmed term when it came from that template, so the strip here only needs to
+ *  cover this function's own regex fallback. */
 function metaTermOf(query, envelope) {
   if (envelope?.parsed?.shape === "meta" && envelope.parsed.object) return envelope.parsed.object;
   const q = String(query).trim();
   const m = q.match(BARE_WHATIS_RE)
     || q.match(/^what\s+(?:does|do)\s+(?:an?\s+)?(.+?)\s+means?[?.!\s]*$/i)
     || q.match(/^define\s+(?:an?\s+)?(.+?)[?.!\s]*$/i);
-  return m ? m[1].trim() : null;
+  return m ? stripTrailingScopeFiller(m[1].trim()) : null;
+}
+
+/** The TEACH-OFFER line for a term that's genuinely unknown everywhere (Tier-5
+ *  playtest fix): "I don't know 'X' yet — teach me directly, e.g. …". The
+ *  concrete example is worded by WORD COUNT, verified in-state
+ *  (SKILL_CHAT_PLAYTEST.md §4's own rule) — an unwrapped bare declarative
+ *  only stores for a single-token subject (BARE_DECLARATIVE_RE's own scope);
+ *  the wrapped "remember X is a Y" form tolerates up to a two-token subject
+ *  (unknownSubjectFallback's UNKNOWN_SUBJECT_RE). A 3+-word term fits
+ *  neither shape — never offer a concrete example that would itself fail,
+ *  the plain nudge to teach it still guides, honestly. Shared by runTurn's
+ *  own "what is X" miss nudge and factAnswer's "what do you know about X"
+ *  miss nudge, below, so the two can never disagree on wording. */
+function unknownVocabTermOffer(term) {
+  const article = /^[aeiou]/i.test(term) ? "an" : "a";
+  const words = term.trim().split(/\s+/);
+  const remember = `remember ${term} is ${article} <thing>`;
+  const example = words.length === 1
+    ? `"${term} is ${article} <thing>" or "${remember}"`
+    : words.length === 2
+      ? `"${remember}"`
+      : null;
+  return `I don't know "${term}" yet — teach me directly${example ? `, e.g. ${example}` : ` (e.g. "remember <name> is ${article} <thing>")`}.`;
 }
 
 /** The curated SEON definition to PREFER for a "what is a <lexicon term>", or null.
@@ -3387,6 +4293,18 @@ async function curatedDefinitionAnswer(query, envelope, { memoryDir, lexicon })
 // SHORTHAND_CONTRACTIONS above: scoped locally to the lane that owns the word.
 // Word-boundary matched so "hotel"/"intel" are untouched.
 const VAGUE_TOUCH_TEL_RE = /\btel\b/i;
+// "abut" -> "about" (Tier 6 playtest, §3b typo axis): a one-letter-dropped
+// typo of THIS lane's own anchor word ("what abut imports" used to miss the
+// "what about …" regex entirely and search for a module literally named
+// "abut" instead). "about" is real English on its own (a genuine word) but is
+// not itself part of ask.mjs's code-graph grammar (VERB_TO_KIND/ENTITY_TO_TYPE/
+// anchor words) — same reasoning as VAGUE_TOUCH_TEL_RE just above, so this
+// stays a local, lane-scoped replace rather than a shared MISSPELLINGS entry
+// (test/ask-vocab.test.mjs enforces every correction TABLE value is grammar-
+// owned; a bare discourse word like "about" fails that gate on purpose).
+// Word-boundary matched so a real identifier merely containing "abut" (rare,
+// but e.g. "rebuttal") is untouched.
+const VAGUE_TOUCH_ABUT_RE = /\babut\b/i;
 /** "explain X" / "please explain X" / "kindly explain X" / "explain X to me" /
  *  "explain X please" — a bare vague-touch shape, sibling of WHAT_ABOUT_RE
  *  above. Named (not inlined) so both vagueTouchTermOf (term extraction) and
@@ -3407,6 +4325,7 @@ function vagueTouchTermOf(query) {
   // bridge frame), breaking this very regex.
   let q = correctMisspellings(String(query).trim());
   q = q.replace(VAGUE_TOUCH_TEL_RE, "tell");
+  q = q.replace(VAGUE_TOUCH_ABUT_RE, "about");
   q = applyPreambleFrames(q);
   const m = q.match(/^(?:kindly\s+)?tell me about\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i)
     || q.match(/^(?:(?:and|so|but|ok|okay|now|then|kindly)\s+)*what about\s+(?:an?\s+|the\s+)?(.+?)(?:\s+then|\s+though)?[?.!\s]*$/i)
@@ -3518,8 +4437,22 @@ function relationTermOf(query, envelope) {
  *  can never parse and always misses) — a drill-down chain that opens with
  *  "describe X" (the README's own example) used to dead-end on the very next
  *  "what about it"/"what about Y" turn. */
+// Bug F point 4 (operator follow-up request): "please tell me X" (no "about")
+// answers like "describe X"/"what is X" — the "tell me" branch's own "about"
+// is now OPTIONAL, so "please tell me Widget" reaches the same rescue "please
+// tell me about Widget" already did. "describe"/"what(?:'s|\s+is)? about" stay
+// unchanged (describe never took "about" at all; the "what about" branch
+// still requires it — a bare "what X" is BARE_WHATIS_RE's own territory, not
+// this lane's, and folding it in here would risk double-claiming that shape).
+// Note the trailing \s+ moved INSIDE each alternation branch (rather than one
+// shared \s+ after the whole group): making "about" optional inside the "tell
+// me" branch means that branch's own separator is sometimes owned by "me\s+"
+// and sometimes by "about\s+" — a single external \s+ double-counted the
+// separator when "about" fired (swallowing the one real space and then
+// requiring a second one that was never there, an always-null regex found
+// live while testing this fix).
 const DESCRIBE_WRAPPER_RE =
-  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?(?:tell\s+me\s+(?:more\s+)?about|describe|what(?:'s|\s+is)?\s+about)\s+(.+?)(?:\s+for\s+me)?(?:\s+please)?\s*\??$/i;
+  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?(?:tell\s+me\s+(?:more\s+)?(?:about\s+)?|describe\s+|what(?:'s|\s+is)?\s+about\s+)(.+?)(?:\s+for\s+me)?(?:\s+please)?\s*\??$/i;
 
 /** Bare focus pronouns this lane resolves against the STANDING focus (0.9.13
  *  Tier-1 playtest) — "describe that" / "tell me about it" after a prior turn
@@ -3542,14 +4475,77 @@ const DESCRIBE_PRONOUN_RE = /^(?:it|that|this|those|them)$/i;
  *  unaffected either way. */
 const STACCATO_PRONOUN_RE = /^(?:and|also|so|then|now)\s+(it|that|this|those|them)(?:\s+ones?)?\s*\??$/i;
 
-async function describeWrapperAnswer(query, { config, source, focus }) {
-  const q = String(query || "").trim();
+/** Tier 6 playtest: "describe the logger module"/"describe the Task class" —
+ *  dispatchTool("tmct_describe") resolves its `symbol` arg via codegraph.mjs's
+ *  resolveSymbol, a separate, simpler path/basename matcher with NO article- or
+ *  grain-word tolerance. A first attempt routed this whole free-text `term`
+ *  through resolveEntity/resolveObject instead (which DOES have that tolerance,
+ *  just added above) — reverted live, found via this same playtest cycle's own
+ *  regression run: resolveObject's tier-3 ANY-overlap fallback is tuned for
+ *  near-path/near-symbol terms, not arbitrary English sentences, and a genuine
+ *  English article ("a", "the") can itself be a real one-character path
+ *  component of some fixture module ("a.mjs") — "tell me A JOKE" tier-3-matched
+ *  that module by the shared bare "a" alone (test/sessions.test.mjs's own guard
+ *  test caught it: a turn meant to fall through as an honest grammar miss
+ *  instead silently "described" an unrelated module). Scoped down to ONLY ever
+ *  attempt a resolution when the term carries an EXPLICIT trailing grain word
+ *  (module/class/function/method/…, ENTITY_TO_TYPE's own closed table) — the
+ *  class-narrowed pool that then searches is both far smaller and still
+ *  requires the head noun to actually match a stem, so it stays safe; a bare
+ *  "the X"/"an X" or ordinary sentence (no grain word) gets NO rescue attempt
+ *  at all and falls through to the untouched, always-safe resolveSymbol path,
+ *  exactly as before this fix. */
+const DESCRIBE_GRAIN_WORD_RE = new RegExp(
+  `^(?:(?:the|a|an)\\s+)?(.+?)\\s+(${Object.keys(ENTITY_TO_TYPE).join("|")})$`, "i",
+);
+async function describeGrainRescue(graph, term) {
+  if (!graph) return null;
+  const m = String(term || "").trim().match(DESCRIBE_GRAIN_WORD_RE);
+  if (!m) return null;
+  const [, head, grainWord] = m;
+  const expectedClass = ENTITY_TO_TYPE[grainWord.toLowerCase()];
+  if (!head?.trim() || !expectedClass) return null;
+  try {
+    const { resolveObject } = await import("./ask.mjs");
+    const r = resolveObject(graph, head.trim(), { expectedClass });
+    if (r?.match?.id && !r.ambiguous) return { id: r.match.id, label: r.match.label };
+  } catch { /* tolerated */ }
+  return null;
+}
+
+async function describeWrapperAnswer(query, { config, source, focus, graph }) {
+  // Tier 6 playtest: this lane is the LAST-RESORT rescue (4d, tried after every
+  // earlier lane declines on the ORIGINAL query) — but it tested its own
+  // DESCRIBE_WRAPPER_RE against the RAW, un-normalized text, so a preamble an
+  // earlier lane (relationForceAnswer/vagueTouchTermOf) already knows how to
+  // strip ("ok cool, what about the TaskController" — relationForceAnswer
+  // correctly declines since "TaskController" isn't an enumerable RELATION_TERM,
+  // but never hands its own stripped text forward) reappeared here, unstripped,
+  // 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());
   const m = DESCRIBE_WRAPPER_RE.exec(q) || STACCATO_PRONOUN_RE.exec(q);
   let term = m?.[1]?.trim();
   if (!term) return null;
   if (DESCRIBE_PRONOUN_RE.test(term)) {
     if (!focus?.label) return null; // no standing focus to resolve against — honest decline
     term = focus.label;
+  } else {
+    const rescued = await describeGrainRescue(graph, term);
+    if (rescued?.label) {
+      term = rescued.label;
+    } else {
+      // Tier 6 playtest: "what about the TaskController" (no grain word, just a
+      // bare article) — resolveSymbol (codegraph.mjs) has no component/overlap
+      // tier at all, only exact/endsWith/basename/includes checks, so a leading
+      // "the"/"a"/"an" is pure NOISE here (unlike resolveObject's looser tiers,
+      // there is no accidental-match risk this could introduce — stripping it
+      // only ever REMOVES characters no real label ever contains as a match
+      // signal). "TaskController" resolves exactly where "the TaskController"
+      // didn't.
+      term = term.replace(/^(?:the|a|an)\s+/i, "");
+    }
   }
   try {
     const text = await dispatchTool("tmct_describe", { symbol: term }, { config, source });
@@ -4008,16 +5004,28 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // guarantees a real answer before it defers, never stranding the turn on a
   // worse outcome — see isStaccatoPronounNoFocus's own docblock for the same
   // discipline).
+  // Tier-5 playtest fix (this session): "is it deprecated" is EXACTLY the same
+  // race BUG 2 (above) fixed for "what is john" — 3 words, no code-ish token,
+  // so isConversationalCandidate would otherwise win unconditionally and a
+  // just-taught property fact ("logger module is deprecated") becomes
+  // unreachable the moment it's asked back about with a short pronoun/bare
+  // form ("is it deprecated" / "is the logger deprecated"). Widened the SAME
+  // divert-only-on-a-real-hit gate to also try IS_ADJECTIVE_YESNO_RE shapes —
+  // factAnswer itself declines for this shape (no metaTerm), so the only
+  // change in practice is that factReadBack's (a2c) property lane gets a
+  // chance to run before the orientation card claims the turn.
+  const bareWhatisShape = BARE_WHATIS_RE.test(String(query).trim());
+  const isAdjectiveShape = IS_ADJECTIVE_YESNO_RE.test(String(query).trim());
   let bareMetaHit = null;
-  if (isConversationalCandidate && memoryDir && BARE_WHATIS_RE.test(String(query).trim())) {
+  if (isConversationalCandidate && memoryDir && (bareWhatisShape || isAdjectiveShape)) {
     bareMetaHit = (await factAnswer(memoryDir, query, envelope, miss))
-      ?? (await factReadBack(memoryDir, query, envelope, miss, graph));
+      ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label));
   }
   if (bareMetaHit) {
     answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
     via = "fact"; recordMiss = false; handled = true;
     if (bareMetaHit.pending) factPending = bareMetaHit.pending;
-    note(trace, "lane: (2b) BARE META FACT — \"what is X\" (no article) resolved to a remembered fact before the conversational catch-all could claim it");
+    note(trace, "lane: (2b) BARE META FACT — \"what is X\" (no article) / \"is X <adjective>\" resolved to a remembered fact before the conversational catch-all could claim it");
     note(trace, "source: .tmct/memory Facts (see /memory for provenance per line)");
   } else if (isConversationalCandidate) {
     // A conversational miss (a greeting, "what can you do", a very short non-code
@@ -4053,7 +5061,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // first (factAnswer), then the reverse-membership read-back (factReadBack) so an
     // asserted "every X is a Y" answers "what is a Y" too.
     const fact = (await factAnswer(memoryDir, query, envelope, miss))
-      ?? (await factReadBack(memoryDir, query, envelope, miss, graph));
+      ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label));
     if (fact) {
       answer = fact.replace ? fact.text : `${answer}\n${fact.text}`;
       via = "fact";
@@ -4061,6 +5069,15 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       if (fact.pending) factPending = fact.pending; // a truncated fact list → paginable remainder
       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
+      // own goal revision just below (Bug 3 point 4) — `deduced` was computed
+      // WAY above off envelope.parsed alone, but a general-verb direct question
+      // ("does margo eat ribs") never parses as a structural graph query at all,
+      // so it either landed on an unrelated GOAL_BY_KIND guess or nothing.
+      if (fact.generalVerbQuery) {
+        deduced = "look up a taught fact about a subject/verb/object";
+        note(trace, `goal: ${deduced} (revised — a general-verb direct-question fact lookup answered this turn)`);
+      }
     } else if (miss) {
       // W2: after the honest miss is composed, consult the folded-session memory. A
       // relevant enough block ANSWERS — recalled Q/A framed + cited first, with the
@@ -4246,7 +5263,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // for what would otherwise become the generic wall, never a competing route:
   // it only claims the turn if /describe actually resolves the captured term.
   if (miss && recordMiss && via === "composed") {
-    const described = await describeWrapperAnswer(query, { config, source, focus: newFocus });
+    const described = await describeWrapperAnswer(query, { config, source, focus: newFocus, graph });
     if (described) {
       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");
@@ -4273,6 +5290,47 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     answer = `${answer}\n(this repo has no code graph — for structure, point me at a \`.tmct/graph.json\` with \`--repo <path>\` or run \`npm run example:mini\`; tmct doesn't index code itself.)`;
     note(trace, "intermediate: HONEST-EMPTY POLISH — the loaded graph has 0 modules, so the dead-end got a --repo/tmct init pointer appended");
   }
+  // TEACH-OFFER (Tier-5 playtest, this session) — SKILL_CHAT_PLAYTEST.md §0
+  // names "'X' isn't a term in this graph's own vocabulary" as its own
+  // dead-end example, and Tier 5 (§3) explicitly wants "the honest 'I don't
+  // know that yet' that offers to learn" rather than a bare wall. A "what is
+  // X" miss where X is genuinely unknown EVERYWHERE — not a real graph entity
+  // (resolveEntity), not a schema/vocab term (that's what "still standing
+  // miss" already means here), and not already in memory (checked directly,
+  // not via factAnswer's OWN metaTerm branch, so this never duplicates its
+  // more specific "no X facts about Y" miss) — gets a short offer appended
+  // UNDER the existing miss text, never replacing it (every pinned assertion
+  // on the miss wording elsewhere stays intact; this is purely additive, the
+  // same discipline the corpus aside (W5) and empty-graph polish above use).
+  if (recordMiss && (via === "composed" || via === "miss") && memoryDir) {
+    // Tier-5 playtest fix (cycle 3): "what do you know about X" is its OWN
+    // sibling shape — checked FIRST (and, unlike metaTermOf below, without a
+    // resolveEntity(graph) gate): it's inherently a MEMORY question, not a
+    // graph-structure one, so "nothing yet, teach me" is appropriate even
+    // when X also happens to be a real graph entity — there's no genuinely
+    // BETTER answer path to defer to the way "what is X" has (the concept
+    // force, schema docs, …). Found live: "what do you know about the last
+    // commit" (nothing in memory, and the whole sentence never fits ask.mjs's
+    // grammar either) fell to the raw wall, unguided.
+    const knowAboutTerm = String(query).trim().match(KNOW_ABOUT_RE)?.[1]?.trim();
+    const offerTerm = knowAboutTerm || metaTermOf(query, envelope);
+    if (offerTerm) {
+      let normFactTerm;
+      try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { normFactTerm = null; }
+      if (normFactTerm) {
+        const cleanTerm = normFactTerm(offerTerm);
+        const ent = knowAboutTerm ? null : await resolveEntity(graph, offerTerm);
+        if (!ent) {
+          const variants = factTermVariants(normFactTerm, offerTerm);
+          const known = (await memoryFacts(memoryDir)).some((f) => variants.has(f.subject) || variants.has(f.object));
+          if (!known) {
+            answer = `${answer}\n${unknownVocabTermOffer(cleanTerm)}`;
+            note(trace, `intermediate: TEACH-OFFER — "${cleanTerm}" is unknown to both the graph and memory, so the miss got an offer to learn appended`);
+          }
+        }
+      }
+    }
+  }
   // W5 (flag-gated, default OFF): an unknown-term miss may consult the LOCAL
   // committed corpus slice — a hit APPENDS a grounded, licence-cited aside under
   // the honest miss (the miss itself stands; the aside is context, not an answer).
@@ -4363,6 +5421,38 @@ function plainTurn(query, answer, { command, via = "composed", miss = false, foc
   };
 }
 
+// Bug F point 5 (operator's explicit, most important ask this round): a
+// command name -> a short, honest one-line goal string, mirroring GOAL_BY_KIND's
+// own spirit (above) — but for COMMAND dispatches (find/search/describe/…)
+// instead of ask()-parsed relation queries, so "I want you to search for
+// Widget" (now reachable via a slash command per Bug F point 3) ALSO gets a
+// real "Goal (inferred): …" line instead of none at all, generalizing the
+// existing mechanism exactly as asked. Reuses GOAL_BY_KIND's EXISTING wording
+// verbatim wherever a command's intent overlaps one of those kinds (members/
+// subclasses reuse contains/inherits's own phrasing; callers/callees reuse
+// calls's; tests/untested reuse tests's; history reuses touches's; exports
+// reuses reexports's) — never invents new phrasing for the same concept. A
+// command not worth a bespoke entry (help/stats/memory/focus/narrate/unknown)
+// falls back to a short generic line in mk() itself, below.
+const GOAL_BY_COMMAND = {
+  find: "locate a specific named entity",
+  search: "locate a specific named entity",
+  context: "gather the sized edit bundle for a symbol before changing code",
+  snippet: "view a symbol's exact source",
+  describe: "look up a symbol's definition and relations",
+  signature: "view a symbol's signature",
+  members: GOAL_BY_KIND.contains,
+  subclasses: GOAL_BY_KIND.inherits,
+  impact: "understand what a change to this module would reach (impact closure)",
+  callers: GOAL_BY_KIND.calls,
+  callees: GOAL_BY_KIND.calls,
+  tests: GOAL_BY_KIND.tests,
+  untested: GOAL_BY_KIND.tests,
+  history: GOAL_BY_KIND.touches,
+  exports: GOAL_BY_KIND.reexports,
+  arch: "understand the overall architecture (package/module boundaries)",
+};
+
 /** A slash-command → the mapped tool (or the /help, /focus, /narrate, unknown
  *  cases). Returns the same { answer, logLines, record, focus } shape as
  *  runAsk; the record carries the command name and the resolved entity id
@@ -4370,7 +5460,10 @@ function plainTurn(query, answer, { command, via = "composed", miss = false, foc
  *  wherever it resolves an entity. `ctx.trace` (narrate mode, or undefined
  *  when off) gets one "goal:"/"lane:" note per branch — a slash-command's
  *  "decision" is simply which command+tool ran, so this is intentionally
- *  lighter than runAsk's miss-cascade instrumentation. */
+ *  lighter than runAsk's miss-cascade instrumentation. Also carries a `goal`
+ *  field now (Bug F point 5) — mirrors runAsk's own `goal` field so
+ *  withGoalLine's short "Goal (inferred): …" line fires for command
+ *  dispatches too, not just ask()-parsed queries. */
 async function runCommand(line, { config, source, graph, focus, memoryDir, trace, narrate = false }) {
   const ts = new Date().toISOString();
   const sp = line.indexOf(" ");
@@ -4381,6 +5474,7 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
     logLines: [ts, `> ${line}`, answer, ""],
     record: { type: "turn", ts, query: line, command: name, via: "command", resolvedIds, answeredIds: [], miss },
     focus: newFocus,
+    goal: GOAL_BY_COMMAND[name] || "use a specific tool/command directly",
     ...(narrateNext !== undefined ? { narrate: narrateNext } : {}),
   });
 
@@ -4441,6 +5535,20 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
     value = focus?.label || "";
     if (value) note(trace, `intermediate: no/pronoun argument -> fell back to the standing focus "${value}"`);
   }
+  // Tier 6 playtest: a bare English "describe the logger module"/"describe the
+  // Task class" is short enough (≤3 tokens, no query connective) that
+  // asBareCommand (above) already rewrote it into a literal slash command
+  // BEFORE this function ever sees it — so describeGrainRescue's OWN lane
+  // (describeWrapperAnswer) never runs for this exact shape; the rescue has to
+  // happen HERE too, on the raw command argument, before it reaches
+  // dispatchTool's resolveSymbol (which has no article/grain-word tolerance).
+  if (entityArg && value) {
+    const rescued = await describeGrainRescue(graph, value);
+    if (rescued?.label) {
+      note(trace, `intermediate: "${value}" carries a grain word -> resolved to ${rescued.label} before dispatch`);
+      value = rescued.label;
+    }
+  }
   if (spec.arg && !spec.optional && !value) {
     const need = entityArg ? `${spec.arg} (none given and no focus set — /focus <x> or pass one)` : spec.arg;
     return mk(`/${name} needs a ${need}.`, { miss: true });
@@ -4570,8 +5678,30 @@ function morePage(query, { last, focus }) {
   return turn;
 }
 
+// Bug F point 3 (operator follow-up request): "I want you to search for
+// Widget" / "I'd like you to search for Widget" — a closed-set indirect-
+// request wrapper, checked VERY early (before asBareCommand/conversationalTurn/
+// the ask engine ever see the raw prefix). Found live: without this, "I want
+// you to search for Widget" was mis-swallowed by GENERAL_VERB_TEACH_RE as a
+// bare <subject> <verb> <object> teach triple (subject "I", verb "want") —
+// declined by the pronoun-subject guard with a confusing "pronouns aren't
+// things I can classify" message, instead of ever reaching /search at all.
+// Deliberately does NOT strip bare "please X" alone — that's already handled
+// ad hoc by many individual regexes throughout this file (TEACH_RE,
+// EXPLAIN_TOUCH_RE, describeWrapperAnswer's own regex, IMPERATIVE_NUDGE_RE) and
+// re-stripping it centrally here risks double-processing interactions across
+// the whole file — out of scope for this fix, higher risk than the concrete
+// 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;
+
 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 } = {}) {
   const line = String(input ?? "").trim();
+  // The captured residue is used for RECOGNITION at every dispatch site below
+  // (asBareCommand, conversationalTurn, assertTurn, the count lanes, runAsk);
+  // 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 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
@@ -4598,6 +5728,14 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // the PRE-narration finished result — see withNarration's docblock for why.
   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) {
+      if (finished.record) finished.record.query = line;
+      if (Array.isArray(finished.logLines) && finished.logLines.length > 1) finished.logLines[1] = `> ${line}`;
+    }
     // runAsk's own effectiveQuery (set only when discourseRewrite substituted a
     // new subject AND the rewrite produced a genuine non-miss answer) takes
     // over as the continuation base for the NEXT turn's own discourseRewrite —
@@ -4617,32 +5755,32 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // "memory", "describe X") is routed to its slash form BEFORE the conversational
   // layer, so a forgiving shell answers "stats" the way it answers "/stats" instead
   // of falling through to the generic orientation.
-  const bareCmd = asBareCommand(line);
+  const bareCmd = asBareCommand(workingLine);
   if (bareCmd) return withLast(await runCommand(bareCmd, ctx), "use a specific tool/command directly");
 
   // Conversational layer next (greetings, thanks, help, bye, why/say-more) — these
   // resolve no entity and carry their own preserved `last`. Bypasses withLast (a
   // conversational turn is never finish()'d / never becomes a new `last`), so the
   // narrate block is applied directly here instead.
-  const convo = conversationalTurn(line, ctx);
+  const convo = conversationalTurn(workingLine, ctx);
   if (convo) return withNarration(convo, trace, "casual/social — no graph intent");
 
   // "more" — page the remainder of a previous long listing, if one is held. Gated on
   // an actual pending remainder so a bare "more" with nothing to continue falls through
   // to the ordinary path (an honest miss), never a pretend page.
-  if (MORE_RE.test(line) && Array.isArray(last?.detail?.pending?.items) && last.detail.pending.items.length) {
+  if (MORE_RE.test(workingLine) && Array.isArray(last?.detail?.pending?.items) && last.detail.pending.items.length) {
     note(trace, "goal: continue viewing a previous long listing (pagination)");
     note(trace, "lane: MORE_RE matched a held pending remainder from the previous turn's detail.pending");
-    return withLast(morePage(line, ctx), "continue viewing a previous long listing");
+    return withLast(morePage(workingLine, ctx), "continue viewing a previous long listing");
   }
 
-  if (line.startsWith("/")) return withLast(await runCommand(line, ctx), "use a specific tool/command directly");
+  if (workingLine.startsWith("/")) return withLast(await runCommand(workingLine, ctx), "use a specific tool/command directly");
   // Declarative ACE sentences ("every module is a artifact") ASSERT into tmct's
   // own memory and confirm — they are statements to remember, not graph queries.
   // Gated on memoryDir: only a session shell provides a write target, so a bare
   // runTurn (tests, library callers) stays pure and falls through to the engine.
   if (memoryDir) {
-    const asserted = await assertTurn(line, ctx);
+    const asserted = await assertTurn(workingLine, ctx);
     if (asserted) {
       note(trace, "goal: teach/remember a new fact (declarative ACE sentence)");
       note(trace, "lane: assertTurn — grammar/ace.mjs parseAce matched a full triple with no residue");
@@ -4655,11 +5793,11 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // otherwise say "I can't count facts"); it only speaks for a memory-class noun, so
   // structural counts (classes/functions/…) and sessions fall through unaffected.
   if (memoryDir) {
-    const memCount = await answerMemoryCount(memoryDir, line);
+    const memCount = await answerMemoryCount(memoryDir, workingLine);
     if (memCount != null) {
       note(trace, "goal: get a count of a memory-store kind (facts/utterances)");
       note(trace, "lane: answerMemoryCount — matched a MEMORY_COUNT_NOUNS entry, answered off the .tmct/memory graph header");
-      return withLast(plainTurn(line, memCount, { via: "count", focus }), "get a count of a memory-store kind");
+      return withLast(plainTurn(workingLine, memCount, { via: "count", focus }), "get a count of a memory-store kind");
     }
   }
   // Feature A point 4: "how many Xs are Ys" — a taught-quantifier RECALL, checked
@@ -4668,32 +5806,32 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // authority gate declines (returns null) for anything answerCount should own,
   // so ordinary structural counts fall through completely unaffected.
   if (memoryDir) {
-    const quantifierRecall = await answerQuantifierRecall(memoryDir, line);
+    const quantifierRecall = await answerQuantifierRecall(memoryDir, workingLine);
     if (quantifierRecall != null) {
       note(trace, 'goal: recall a taught quantifier for a class-membership pair ("how many Xs are Ys")');
       note(trace, "lane: answerQuantifierRecall — matched HOW_MANY_ARE_RE with a subject tmct has facts about; literal recall, never real counting");
-      return withLast(plainTurn(line, quantifierRecall, { via: "fact", focus }), "recall a taught quantifier");
+      return withLast(plainTurn(workingLine, quantifierRecall, { via: "fact", focus }), "recall a taught quantifier");
     }
   }
   // Aggregate/count questions are answered mechanically off the loaded graph header,
   // BEFORE falling through to the ask engine (focus unchanged — a count names no entity).
-  const count = answerCount(graph, line);
+  const count = answerCount(graph, workingLine);
   if (count != null) {
     // An "I can't count <noun>" from a bare kind may still be answerable from an
     // ASSERTED vocabulary fact ("every class is a type" → "how many types" = the
     // class count). countFromFacts declines on a real graph kind, so ordinary
     // counts are unaffected; it only speaks for a remembered object noun.
-    const viaFact = memoryDir ? await countFromFacts(graph, memoryDir, line) : null;
+    const viaFact = memoryDir ? await countFromFacts(graph, memoryDir, workingLine) : null;
     if (viaFact != null) {
       note(trace, 'goal: get a count of an asserted-vocabulary kind ("every X is a Y" inherited cardinality)');
       note(trace, "lane: countFromFacts — the counted noun matched a remembered isa-fact's SUBJECT, whose class IS countable");
-      return withLast(plainTurn(line, viaFact, { via: "fact", focus }), "get a count");
+      return withLast(plainTurn(workingLine, viaFact, { via: "fact", focus }), "get a count");
     }
     note(trace, "goal: get a count of a graph kind (classes/functions/modules/…)");
     note(trace, "lane: answerCount — a header-count aggregate question, answered mechanically off the graph header, never dispatched to the ask engine");
-    return withLast(plainTurn(line, count, { via: "count", focus }), "get a count of a graph kind");
+    return withLast(plainTurn(workingLine, count, { via: "count", focus }), "get a count of a graph kind");
   }
-  return withLast(await runAsk(line, ctx), "unclear — no goal signal computed by the ask engine");
+  return withLast(await runAsk(workingLine, ctx), "unclear — no goal signal computed by the ask engine");
 }
 
 // ---- W3: seedMemory → bootstrap (first run in a graph-less repo) ----