@polycode-projects/the-mechanical-code-talker 1.4.1 → 1.5.2

package/src/chat.mjs

@@ -56,9 +56,9 @@ import { rankByBiasThenTrust } from "./memory/bias.mjs";
 import { finish, beginsWithVowelSound, grammarRules } from "./finish.mjs";
 import {
   VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE, PASSIVE_PARTICIPLE_TO_KIND,
-  stripTrailingScopeFiller,
+  stripTrailingScopeFiller, stripTrailingDiscourseTag,
 } from "./ask-vocab.mjs";
-import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames } from "./interpret/normalize.mjs";
+import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, escapeRegex } from "./interpret/normalize.mjs";
 import { fuzzyMatchInSet, fuzzyBound } from "./interpret/fuzzy.mjs";
 
 // uuidv7 lives in ./uuid.mjs (shared with telemetry + the bench stamp); re-exported
@@ -156,6 +156,7 @@ function deduceGoalFromParsed(parsed) {
   if (shape === "meta") return `understand a vocabulary/definition term ("${parsed.object}")`;
   if (shape === "where") return `locate where something is defined ("${parsed.object}")`;
   if (shape === "when") return "understand when something last changed (history)";
+  if (shape === "whoLast") return "find who most recently touched something (history)";
   if (shape === "mentions") return `find where something is mentioned in prose ("${parsed.object}")`;
   if (shape === "ask") return (kind && GOAL_BY_KIND[kind]) || "check a specific subject/object relationship";
   if ((shape === "reverse" || shape === "forward") && kind) return GOAL_BY_KIND[kind] || `understand a "${kind}" relationship`;
@@ -698,7 +699,12 @@ export function renderStats(graph) {
  *  which meant "who are you" always got the "here's what I can query" blurb and
  *  never a self-description — split so each gets the answer it actually asked for. */
 const CAPABILITY_PHRASES = [
-  /^what can (you|u) do\??$/i, /^what do you do\??$/i, /^help( me)?\??$/i, /^\?+$/,
+  // HANDOVER.md 2026-07-10 item 10: "what can you actually do" (an intensifier
+  // adverb inserted before the verb) used to miss this exact-match regex entirely
+  // and fall to the raw grammar wall instead of orientationAnswer — the same
+  // question in every way that matters, just phrased with emphasis.
+  /^(?:so,?\s+)?what can (?:you|u)(?:\s+(?:actually|really))? do\??$/i, /^(?:so,?\s+)?what do you(?:\s+(?:actually|really))? do\??$/i,
+  /^help( me)?\??$/i, /^\?+$/,
   /^how do (i|you) work\??$/i, /^how does (this|it) work\??$/i,
   // unix-habit openers typed inside the REPL out of muscle memory — argv-only
   // today (bin/tmct.mjs), dead once inside the chat loop; route to the same
@@ -770,11 +776,28 @@ const IDENTITY_PHRASES = [
  *  a genuinely different, more specific answer than the generic self-description,
  *  and this is a very likely first question given how most chat tools work today. */
 const AI_IDENTITY_PHRASES = [
-  /^(are you|r u) (an? )?(ai|a bot|chatgpt|gpt|an? llm|a language model|a robot)\??$/i,
+  // HANDOVER.md 2026-07-10 item 10: "are you secretly GPT" — an adverb ("secretly"/
+  // "really"/"actually") wedged between "are you" and the noun (a deliberate-breaker
+  // persona's own phrasing) used to mis-segment the subject as "you secretly" and
+  // fall through to the ordinary graph-query grammar instead of this lane.
+  /^(are you|r u)\s+(?:secretly|really|actually)?\s*(an? )?(ai|a bot|chatgpt|gpt|an? llm|a language model|a robot)\??$/i,
   /^is this (chatgpt|gpt|claude|an? ai|an? llm)\??$/i,
   /^do you use ai\??$/i, /^what language model are you( using)?\??$/i,
   /^am i (talking|speaking|chatting) (to|with) a (real )?(person|human|bot|ai)\??$/i,
 ];
+/** "Do you have feelings/emotions" — HANDOVER.md 2026-07-10 item 10 (small-talk
+ *  persona finding): with no closed-set match, this used to misfire into a
+ *  literal module-name lookup for the bare noun ("no module matching 'feelings'
+ *  found in the index") — a wrong-flavor wall, not an honest personality decline.
+ *  Same family/placement as AI_IDENTITY_PHRASES just above (a self-awareness
+ *  question about tmct, not a code-graph query), checked in conversationalTurn
+ *  BEFORE any graph query is attempted. */
+const FEELINGS_PHRASES = [
+  /^do you have (?:feelings|emotions|opinions|thoughts)\??$/i,
+  /^are you (?:sentient|conscious|self[- ]aware)\??$/i,
+  /^can you feel(?:\s+(?:things|emotions|anything))?\??$/i,
+  /^do you (?:feel|think|dream)\??$/i,
+];
 /** The structural verbs/nouns that mark a near-miss code question (→ keep the
  *  precise grammar hint, not the friendly nudge). */
 const STRUCT_WORDS = new Set([
@@ -843,6 +866,7 @@ const T_ORIENTATION_EMPTY = "orientation-empty";
  *  depend on whether a repo is loaded. */
 const T_IDENTITY_SELF = "identity-self";
 const T_IDENTITY_NOT_LLM = "identity-not-an-llm";
+const T_IDENTITY_NO_FEELINGS = "identity-no-feelings";
 /** THE CONCEPT FORCE (concept.mjs): the three-band answer to a vague "what is a X"
  *  that names a known concept WITH instances — {definition}/{examples}/{followups}. */
 const T_CONCEPT = "concept-force";
@@ -895,11 +919,27 @@ 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",
+  // "brilliant" (playtest sprint round 3, 2026-07-10): a UK-English enthusiasm
+  // interjection functioning as a bare acknowledgement, the same shape as
+  // "nice"/"cheers" just above — "brilliant, that's all I needed" hit the raw
+  // grammar wall via item 2's own multi-clause scan (which deliberately checks
+  // THANKS only, not OK_ACK — see farewellOrThanksSignal's own docblock for why
+  // "ok"/"cool"/"right" stay excluded there) because "brilliant" wasn't in
+  // EITHER closed set yet.
+  "brilliant",
   // "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",
+  // Playtest sprint round 3 (2026-07-10): a natural session-closing remark
+  // hit the raw grammar wall instead of a warm sign-off — the LAST turn of a
+  // session is a bad place to end on a wall. Same discipline as "ta for
+  // that": add the SPECIFIC found phrasing, not a general "closing remark"
+  // grammar.
+  "cheers, that's everything for now, thanks",
+  "that's everything for now, thanks",
+  "that's all for now, thanks",
 ]);
 /** Farewells → a goodbye AND a clean end of session (same path as /exit). */
 const BYE = new Set([
@@ -957,6 +997,82 @@ function closedOrCollapsed(q, set, idx) {
   return idx.get(collapseRuns(q)) ?? null;
 }
 
+/** HANDOVER.md 2026-07-10 item 2: THANKS/BYE were exact-match-the-WHOLE-line
+ *  closed sets, grown one literal phrase at a time across sessions — and kept
+ *  failing on the very next unlisted phrasing tried (3 independently-run
+ *  personas each hit this in one persona-sweep: "thanks, that was fun",
+ *  "ok thank you very much, bye bye", "thanks, bye"). The generalization is
+ *  over PHRASE SHAPE (a thanks/bye clause tacked onto a larger sentence),
+ *  not another one-off literal string:
+ *    - split on comma/semicolon/a standalone "and" into clauses
+ *    - strip a leading bare OK_ACK lead-in off each clause ("ok thank you…")
+ *    - strip a trailing intensifier ("very much"/"so much"/"a lot"/"a bunch" —
+ *      the SAME curated set THANKS_PREAMBLE_RE, interpret/normalize.mjs,
+ *      already recognizes) before matching THANKS
+ *    - fold an exact word-repeated clause ("bye bye") to one instance before
+ *      matching BYE — informal reduplication for emphasis, not a new phrase
+ *  Still the SAME closed THANKS/BYE sets underneath (same closedOrCollapsed
+ *  matcher) — only the SEGMENTATION generalizes. Bounded to short, non-codeish
+ *  lines (same discipline as isConversational/fuzzyConversationalMatch) so a
+ *  genuine structural question is never grabbed. A single-clause line (no
+ *  comma/semicolon/"and") is left to the exact whole-line checks above/below —
+ *  this only handles the MULTI-clause case those can't. Returns "bye"/"thanks"/
+ *  null; bye wins when a line carries both (a farewell should end the session
+ *  even alongside a thanks — the small-talk persona's "thanks, bye" finding:
+ *  the README implies "bye" phrasing should end the session, full stop). */
+const ACK_LEAD_RE = new RegExp(`^(?:${[...OK_ACK].map(escapeRegex).join("|")})\\s+(.+)$`, "i");
+const TRAILING_INTENSIFIER_RE = /\s+(?:very\s+much|so\s+much|a\s+lot|a\s+bunch)\s*$/i;
+const REPEATED_WORD_RE = /^(\S+)\s+\1$/i;
+// Comma/semicolon (optionally swallowing a following "and") OR a standalone
+// "and" — a single combined pattern so "X, and Y" splits into ["X", "Y"], not
+// ["X", "and Y"] (a naive comma-only split leaves "and" glued to the second
+// clause, which then fails every closed-set match downstream).
+const CLAUSE_SPLIT_RE = /\s*[,;]\s*(?:and\s+)?|\s+and\s+/;
+function conversationalClauses(q) {
+  return q.split(CLAUSE_SPLIT_RE).map((c) => c.trim()).filter(Boolean);
+}
+/** BYE match tolerant of informal reduplication ("bye bye", "no no" — general,
+ *  not specific to any one word): a clause consisting of the SAME word twice
+ *  folds to one instance before the ordinary closed/collapsed BYE lookup.
+ *  Shared by the single-clause whole-line check and the multi-clause scan
+ *  below, so "bye bye" resolves the same way whether or not a comma follows it. */
+function foldedBye(clause) {
+  if (closedOrCollapsed(clause, BYE, BYE_COLLAPSED)) return true;
+  const folded = clause.match(REPEATED_WORD_RE);
+  return !!(folded && closedOrCollapsed(folded[1], BYE, BYE_COLLAPSED));
+}
+function farewellOrThanksSignal(raw, q) {
+  const words = q.split(/\s+/).filter(Boolean);
+  if (words.length < 2 || words.length > 8 || looksCodeish(raw, q)) return null;
+  const clauses = conversationalClauses(q);
+  if (clauses.length < 2) return null; // single-clause lines: the exact whole-line checks own this
+  // OK_ACK is deliberately NOT a signal here (unlike the exact whole-line check
+  // above/below): "ok"/"cool"/"right"/"sure" are constitutionally ACK-PREAMBLE
+  // words in this codebase (ACK_PREAMBLE_RE, interpret/normalize.mjs) — "right,
+  // can you walk me through this codebase" is an ack-preamble before a REAL
+  // question, not a closing acknowledgement, and treating a bare OK_ACK clause
+  // as a thanks-signal regressed exactly that live case. THANKS itself is more
+  // specific (genuine gratitude words rarely lead into an unrelated question),
+  // but still gated below: a THANKS-hit only counts when every OTHER clause is
+  // itself small-talk-shaped (≤3 words, non-codeish) — the SAME bound
+  // isConversational's own catch-all uses — so "cheers, what does X do" is left
+  // to the existing THANKS_PREAMBLE_RE lane, never grabbed here.
+  let thanksClauseIdx = -1;
+  let byeHit = false;
+  for (let i = 0; i < clauses.length; i += 1) {
+    const rawClause = clauses[i];
+    const ackMatch = rawClause.match(ACK_LEAD_RE);
+    const clause = ackMatch ? ackMatch[1].trim() : rawClause;
+    if (foldedBye(clause)) { byeHit = true; break; }
+    const deIntensified = clause.replace(TRAILING_INTENSIFIER_RE, "").trim();
+    if (thanksClauseIdx < 0 && closedOrCollapsed(deIntensified, THANKS, THANKS_COLLAPSED)) thanksClauseIdx = i;
+  }
+  if (byeHit) return "bye";
+  const thanksHit = thanksClauseIdx >= 0 && clauses.every((c, i) => i === thanksClauseIdx
+    || (c.split(/\s+/).filter(Boolean).length <= 3 && !looksCodeish(c, c.toLowerCase())));
+  return thanksHit ? "thanks" : null;
+}
+
 /** The fuzzy-typo fallback's candidate pool: every canonical phrase across the
  *  closed conversational sets, flattened once. Consulted only after every exact/
  *  collapsed lookup misses (see fuzzyConversationalMatch). */
@@ -1050,11 +1166,29 @@ function conversationalTurn(line, ctx) {
       ...(end ? { end: true } : {}),
     };
   };
-  if (BYE.has(q)) {
+  if (foldedBye(q)) {
     note(ctx.trace, "goal: casual/social — ending the session (no graph intent)");
-    note(ctx.trace, "lane: conversational — farewell (BYE closed set)");
+    note(ctx.trace, "lane: conversational — farewell (BYE closed set, incl. bare reduplication e.g. \"bye bye\")");
     return mk(t(T_FAREWELL), { end: true });
   }
+  {
+    // HANDOVER.md 2026-07-10 item 2: a multi-clause line carrying a bye/thanks
+    // clause tacked onto a larger sentence ("thanks, that was fun", "ok thank
+    // you very much, bye bye", "thanks, bye") — see farewellOrThanksSignal's
+    // own docblock. Never fires on a single-clause line (those are the exact
+    // checks just above/below), so this only ADDS coverage, never shadows it.
+    const signal = farewellOrThanksSignal(raw, q);
+    if (signal === "bye") {
+      note(ctx.trace, "goal: casual/social — ending the session (no graph intent)");
+      note(ctx.trace, "lane: conversational — farewell (multi-clause phrase-shape match)");
+      return mk(t(T_FAREWELL), { end: true });
+    }
+    if (signal === "thanks") {
+      note(ctx.trace, "goal: casual/social — acknowledgement, no graph intent");
+      note(ctx.trace, "lane: conversational — thanks (multi-clause phrase-shape match)");
+      return mk(t(T_THANKS));
+    }
+  }
   if (WHY.has(q)) {
     note(ctx.trace, "goal: elaborate on the previous answer (why/say-more)");
     note(ctx.trace, "lane: conversational — why/say-more (WHY closed set)");
@@ -1098,6 +1232,11 @@ function conversationalTurn(line, ctx) {
     note(ctx.trace, "lane: conversational — identity/AI (AI_IDENTITY_PHRASES closed set)");
     return mk(t(T_IDENTITY_NOT_LLM));
   }
+  if (FEELINGS_PHRASES.some((re) => re.test(raw))) {
+    note(ctx.trace, "goal: identity — does tmct have feelings/consciousness (small-talk persona finding)");
+    note(ctx.trace, "lane: conversational — identity/feelings (FEELINGS_PHRASES closed set)");
+    return mk(t(T_IDENTITY_NO_FEELINGS));
+  }
   if (IDENTITY_PHRASES.some((re) => re.test(raw))) {
     note(ctx.trace, "goal: identity — who/what tmct is, not a capability listing");
     note(ctx.trace, "lane: conversational — identity (IDENTITY_PHRASES closed set)");
@@ -1402,6 +1541,53 @@ const OWNS_PASSIVE_TEACH_RE = /^(.+?)\s+(?:is|are|was|were)\s+owned\s+by\s+([A-Z
 const RELATION_FACT_TEACH_RE =
   /^([\w'-]+(?:\s+[A-Z][\w'-]*)?)\s+(?:is|are|was|were)\s+the\s+([a-z][\w-]*)\s+of\s+([\w'-]+(?:\s+[A-Z][\w'-]*)?)[.!?]*$/i;
 
+/** "every/a/an/the <N1> has a/an <N2> method" — the HAS-A-METHOD teach
+ *  declarative (HANDOVER.md 2026-07-10 item 9, a new pattern the operator
+ *  explicitly authorized this session — NOT one of PLAN_TAUGHT_RELATIONS.md's
+ *  own six items): a possession-of-capability claim about a class/entity's
+ *  method ("every Component has a render method", "a Widget has a render
+ *  method"). Before this pattern existed, this exact phrasing reached NO teach
+ *  recognizer at all: RELATION_FACT_TEACH_RE (above) requires a literal "is/
+ *  are the ROLE of", never "has a ROLE method"; GENERAL_VERB_TEACH_RE (below)
+ *  maps "has"/"have" onto the same HAS_A_PREDICATE this pattern uses, but only
+ *  for a BARE, wrapper-required, single-token subject with NO leading
+ *  determiner (GENERAL_VERB_DETERMINER_RE explicitly declines "every"/"a"/
+ *  "the" as a subject, by design — see its own docblock) — so a determiner-led
+ *  subject (the operator's own canonical example, "every Component…") fell
+ *  all the way through teachLane, landing on ask.mjs's own structural
+ *  "defines" grammar instead (VERB_TO_KIND maps "has"/"have" to the code-graph
+ *  "defines" relation), which can't resolve "Component"/"render" as real
+ *  code-graph entities and reports the vague, non-actionable
+ *  `"couldn't resolve one of the terms in this question."` wall — exactly the
+ *  symptom HANDOVER.md item 9 names.
+ *
+ *  Deliberately a NARROW, EXPLICIT new pattern, not a widening of
+ *  GENERAL_VERB_TEACH_RE's own bare-subject shape (this project's own
+ *  discipline: small curated closed-set patterns, each independently tested,
+ *  never one generalized catch-all) — the literal trailing word "method" is
+ *  the anchor that keeps this pattern structurally DISJOINT from
+ *  generalVerbTeach's broader "X has a Y" territory (an ordinary "TaskController
+ *  has a hat" still never matches here, and falls through to generalVerbTeach
+ *  unaffected). Tried on the SAME ownSrc the other relational/possessive teach
+ *  shapes above already use, ahead of generalVerbTeach's own call site, so a
+ *  wrapped sentence with NO determiner ("remember that Component has a render
+ *  method" — already handled by generalVerbTeach today) is claimed here first
+ *  instead, producing the byte-identical stored fact and confirmation text —
+ *  a widening of COVERAGE (the determiner-led/bare-unwrapped case), never a
+ *  behavior change to the case that already worked.
+ *
+ *  Predicate minting reuses the EXISTING HAS_A_PREDICATE (mgx:hasA) —
+ *  generalVerbTeach's own has/have special case already mints this, so a fact
+ *  taught via either recognizer reads back interoperably. m[1] = the subject
+ *  (N1, "Component"); m[2] = the capability word (N2, "render") — stored as
+ *  the object `"<N2> method"` ("render method"), so the query-side readers
+ *  below (HAS_METHOD_YESNO_RE/HAS_METHOD_OPEN_RE) can match on the whole
+ *  "<capability> method" phrase, never just the bare capability word (which
+ *  would risk colliding with an unrelated mgx:hasA fact about the same
+ *  capability noun taught some other way). */
+const TEACH_HAS_METHOD_RE =
+  /^(?:every\s+|each\s+|all\s+|a\s+|an\s+|the\s+)?([A-Za-z][\w'-]*)\s+has\s+an?\s+([a-z][\w-]*)\s+method[.!?]*$/i;
+
 /** "a <name> is a <base1> of a <base2>" — the fixed-hop COMPOSITION-RULE teach
  *  declarative (PLAN_TAUGHT_RELATIONS.md Item 3, Phase 4): "a grandparent is a
  *  parent of a parent" teaches a RULE (mgx:ruleKind "compose2"), never a Fact —
@@ -1653,8 +1839,17 @@ async function ungroundedPairHint(payload, lexicon, memoryDir) {
   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}".`;
+  // 2026-07-10 (found live via SKILL_BENCHMARK_CONVERSATION.md playtest, a
+  // classic first-thing-a-user-tries example: "john is a man"): the original
+  // suggestion chained the second term UNDER the first's now-grounded proper
+  // name ("every man is a john") — technically accepted by the grammar (once
+  // "john" is grounded, ANY term can be taught as a kind of it), but reads as
+  // nonsense to a human, since a proper name is never a category. Ground both
+  // sides independently instead — two clear, parallel, semantically sane
+  // suggestions, not a confusing chain through an arbitrary first term.
+  return ` I don't know "${subjectRaw}" or "${objectRaw}" yet. Try grounding each one first, e.g. `
+    + `"every ${subjectRaw} is a thing" and "every ${objectRaw} is a thing", then re-teach the`
+    + ` original fact.`;
 }
 
 /** The unknown-SUBJECT direct-write fallback (point 1 + point 2's bare-property
@@ -2187,6 +2382,26 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
     if (stored) return stored;
   }
 
+  // HAS-A-METHOD TEACH — "every/a/an/the <N1> has a/an <N2> method"
+  // (HANDOVER.md 2026-07-10 item 9): a possession-of-capability claim, stored
+  // as an ordinary Fact via the SAME HAS_A_PREDICATE generalVerbTeach's own
+  // has/have special case already uses (see TEACH_HAS_METHOD_RE's own
+  // docblock above for the full design). Grouped with the other relational/
+  // possessive teach shapes above, tried on the SAME ownSrc, unconditionally
+  // ahead of generalVerbTeach's own call site below — disjoint from
+  // RELATION_FACT_TEACH_RE just above (that shape requires a literal "the
+  // ROLE of", never "has a … method") and from generalVerbTeach's own bare-
+  // subject shape (this one is the ONLY recognizer in this lane that accepts
+  // a leading determiner — "every"/"a"/"an"/"the" — before a "has a … method"
+  // claim).
+  const hasMethod = ownSrc.match(TEACH_HAS_METHOD_RE);
+  if (hasMethod && memoryDir && !QUESTION_LEAD_RE.test(ownSrc)) {
+    const stored = await teachFact(memoryDir, sessionId, {
+      subject: hasMethod[1], predicate: HAS_A_PREDICATE, object: `${hasMethod[2]} method`,
+    });
+    if (stored) return stored;
+  }
+
   // COMPOSE2 RULE TEACH — "a <name> is a <base1> of a <base2>"
   // (PLAN_TAUGHT_RELATIONS.md Item 3, Phase 4): stores a RULE (appendRule,
   // kind "compose2"), never a Fact — tried right after item 1's relational
@@ -2451,10 +2666,17 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
       }
     } catch { /* lexicon unavailable — fall through to the generic message */ }
   }
+  // HANDOVER.md 2026-07-10 item 3: this used to claim "I can only teach facts
+  // using tmct's own code-vocabulary nouns" — false (general vocabulary teaching
+  // is fully supported elsewhere, e.g. "Paris is the capital of France" stores
+  // directly, and unknownSubjectFallback/ungroundedPairHint above both accept
+  // ANY new vocabulary once one side is grounded). The real constraint named
+  // here now: at least one side of a fact must already be grounded (or the
+  // sentence must fit a specific relation shape) — not a vocabulary restriction.
   const why = unknown.length
     ? ` I don't recognize ${joinList(unknown.map((w) => `"${w}"`))} as ${unknown.length === 1 ? "a word" : "words"} I know — `
-      + "I can only teach facts using tmct's own code-vocabulary nouns (like module, class, function…), "
-      + "not arbitrary new terms."
+      + "any vocabulary works, but at least one side of a fact needs to already be grounded to something I "
+      + "know (or fit one of my specific relation shapes), not two brand-new terms at once."
     : "";
   // Grounding NUDGE (operator refinement, 2026-07-09): APPENDED, never a
   // replacement, exactly like "did" above — see ungroundedPairHint's own
@@ -2484,7 +2706,16 @@ const WHAT_KNOW_RE = /^(?:what\s+(?:do\s+you|d'?you)\s+know(?:\s+so\s+far)?|what
 // 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)|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))?)$/;
+// Playtest sprint round 1 (2026-07-10): "what does this do" — the bare pronoun,
+// no explicit noun — used to fall through this lane entirely (the "do" branch
+// required an explicit app/code/codebase/project/repo noun after this/the) into
+// MODULE_ORIENT_RE, which tried to resolve "this" as a graph entity, failed, and
+// hit the raw grammar wall — even though the identical-intent "what can you tell
+// me about this project" already answers cleanly via this same lane. The noun is
+// now OPTIONAL after "this" specifically (kept REQUIRED after "the", since bare
+// "what does the do" is not real input) — a natural stranger-opener that was one
+// token away from already working.
+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(?:\s+(?:app|code|codebase|project|repo))?\s+do|what\s+does\s+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
@@ -3364,8 +3595,30 @@ const GENERIC_ENTITY_WORDS = new Set([
  *  index admits only SINGLE-WORD, purely-alphabetic ConceptNet endpoints on
  *  BOTH sides of a row — a first-cut heuristic filter, not a full manual
  *  review of all 1,228 rows (a natural follow-up, not claimed as done here).
- *  Lazy + failure-tolerated: a missing/broken corpus file degrades to an
- *  empty (or phrasebook-only) index, never a throw. */
+ *  A FOLLOW-UP spot check (later dispatch, same plan) sampled the 903 rows
+ *  this heuristic admits and confirmed the risk note is real even after the
+ *  single-word filter: generic-English collisions ("battalion"~"heap",
+ *  "bash"~"sock") and, more dangerously, IN-DOMAIN false synonyms — pairs
+ *  where both endpoints are real software terms but are NOT interchangeable
+ *  ("interpreter"~"compiler", "string"~"thread") — the exact "confidently
+ *  wrong within the domain" failure this codebase's ground rules treat as
+ *  worse than an honest miss. SYNONYM_DENYLIST below removes the specific
+ *  false pairs found by that spot check (a manually-reviewed blocklist, the
+ *  same shape as `conceptnet-map.toml`'s own reviewed relation-gate — not a
+ *  general noise heuristic); a full manual review of the remaining ~900
+ *  rows is still the honest follow-up, not claimed as done here either. */
+const SYNONYM_DENYLIST = new Set([
+  ["interpreter", "compiler"], // different execution strategies, not synonyms
+  ["string", "thread"], // unrelated CS concepts (text data vs. execution thread)
+  ["heart", "kernel"], // generic-English collision on "kernel"
+  ["battalion", "heap"], // generic-English collision on "heap" (data structure)
+  ["bash", "sock"], // generic-English collision ("bash"/"sock" = to hit)
+  ["command", "skill"], // too loose to be a safe query-time substitution
+  ["docker", "longshoreman"], // proper-noun/tool name vs. unrelated profession
+  ["name", "list"], // generic-English collision, not a domain synonym
+  ["list", "number"], // generic-English collision, not a domain synonym
+].map(([a, b]) => [a, b].sort().join("|")));
+
 let synonymIndexCache = null;
 async function synonymIndex() {
   if (synonymIndexCache) return synonymIndexCache;
@@ -3374,6 +3627,7 @@ async function synonymIndex() {
     const ta = String(a || "").trim().toLowerCase();
     const tb = String(b || "").trim().toLowerCase();
     if (!ta || !tb || ta === tb) return;
+    if (SYNONYM_DENYLIST.has([ta, tb].sort().join("|"))) return;
     if (!index.has(ta)) index.set(ta, []);
     if (!index.get(ta).some((e) => e.variant === tb)) index.get(ta).push({ variant: tb, source });
     if (!index.has(tb)) index.set(tb, []);
@@ -3460,9 +3714,17 @@ const RELATION_FACT_YESNO_RE =
  *  below — a `resolveRelationChaseReverse` closure re-deriving the SAME
  *  resolution logic as (a0)'s `resolveRelationChase` (direct fact, alias via
  *  findIsaChain, compose2 via a reverse hop-counted chase, filter via a
- *  recursive base-then-property chase), walked backward from the object. */
+ *  recursive base-then-property chase), walked backward from the object.
+ *  HANDOVER.md 2026-07-10 item 3 (teach-then-recall gap): "who" also accepts
+ *  "what" — a taught relation whose role isn't a person ("paris is the capital
+ *  of france") reads naturally as "what is the capital of france", and the
+ *  resolution below is identical either way (it just returns the satisfying
+ *  subject(s)); the two words never compete for a query built from a DIFFERENT
+ *  shape, since T5's bare meta-whatis grammar shape ("what is X") only wins the
+ *  turn when factAnswer/factReadBack's own more specific readers upstream (this
+ *  one included) have already declined. */
 const RELATION_WHO_ASK_RE =
-  /^who\s+(?:is|are)\s+(?:the|an?)\s+([a-z][\w-]*)\s+of\s+([\w'-]+(?:\s+[A-Z][\w'-]*)?)[?.!\s]*$/i;
+  /^(?:who|what)\s+(?:is|are)\s+(?:the|an?)\s+([a-z][\w-]*)\s+of\s+([\w'-]+(?:\s+[A-Z][\w'-]*)?)[?.!\s]*$/i;
 
 /** "list the descendants of ahab" — the REACHABILITY-SET list query
  *  (PLAN_TAUGHT_RELATIONS.md Item 6, Phase 6's wiring half): a genuine
@@ -3480,6 +3742,21 @@ const RECURSIVE_LIST_ASK_RE = /^list\s+(?:the\s+|all\s+)?([a-z][\w-]*)\s+of\s+([
  *  doesn't parse; checked against the isa-family fact predicates only. */
 const ISA_ASK_RE = /^(?:is|are)\s+(?:an?\s+)?(.+?)\s+(?:a\s+kind\s+of|a\s+type\s+of|an?)\s+(.+?)[?.!\s]*$/i;
 const ISA_PREDICATES = new Set(["rdfs:subClassOf", "rdf:type"]);
+/** "so john is a man now right?" / "john is a man, right?" — a DECLARATIVE
+ *  statement wrapped in a confirmation-check tag ("now right?"/"right?"/
+ *  "correct?"), found live (playtest sprint round 1, 2026-07-10) after a
+ *  just-declined teach attempt: the user reasonably assumes it worked and
+ *  asks to confirm — but this shape doesn't match ISA_ASK_RE at all (no
+ *  leading "is/are"), so it fell to the fully GENERIC grammar wall instead of
+ *  the same (already ISA-tailored) honest miss/hint the plain "is X a Y" form
+ *  gets. Deliberately narrow (requires "right?"/"correct?"/"yeah?" as the
+ *  VERY LAST word, optionally preceded by "now" and/or a comma) so it can
+ *  only ever REDIRECT a would-be-wall to the isaAsk block's own answer —
+ *  never a fabricated confirmation, and never touches phrasings that already
+ *  have their own home (e.g. OPINION_NUDGE_RE's own "is the code good"
+ *  ordering is unaffected — that starts with "is", leaving no room for this
+ *  regex's required leading subject clause). */
+const CONFIRM_TAG_RE = /^(?:so\s+)?(.+?)\s+(?:is|are)\s+(?:an?\s+)?(.+?)\s*,?\s*(?:now\s+)?(?:right|correct|yeah)\??$/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
@@ -3645,6 +3922,32 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
     // 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;
+    // LIVE CONSISTENCY CHECK (PLAN_INFERENCE_TESTING.md INF-C2, §4 stage 5):
+    // before answering from this subject's memory, check whether its OWN
+    // taught/entailed types contradict each other (x rdf:type C1, x rdf:type
+    // C2, C1 owl:disjointWith C2, lifted through both types' ⊑-ancestor
+    // closures) via syllogise.mjs's findConsistencyViolations, LIVE and
+    // READ-ONLY — same discipline as the cax-dw chase in the isaAsk block
+    // above. A hit REFUSES the whole answer (every belief about a
+    // contradictory subject is suspect, not just the clashing pair) rather
+    // than silently answering from a memory that's already inconsistent.
+    const { findConsistencyViolations, TYPE_PREDICATE: CONS_TYPE_PREDICATE, SUBCLASS_PREDICATE: CONS_SC_PREDICATE, DISJOINT_PREDICATE: CONS_DISJOINT_PREDICATE } = await import("./syllogise.mjs");
+    const consIsTaught = (f) => !f.provenance?.includes("corpus:") && !f.provenance?.includes("web:");
+    const consTypeEdges = rows.filter((f) => f.predicate === CONS_TYPE_PREDICATE && consIsTaught(f)).map((f) => [f.subject, f.object]);
+    const consSubClassEdges = rows.filter((f) => f.predicate === CONS_SC_PREDICATE && consIsTaught(f)).map((f) => [f.subject, f.object]);
+    const consDisjointEdges = rows.filter((f) => f.predicate === CONS_DISJOINT_PREDICATE && consIsTaught(f)).map((f) => [f.subject, f.object]);
+    if (consDisjointEdges.length) {
+      const clashes = findConsistencyViolations(consTypeEdges, consSubClassEdges, consDisjointEdges, { focus: variants, budget: 5 });
+      const clash = clashes.find((c) => variants.has(c.subject));
+      if (clash) {
+        return {
+          text: `I can't answer that — what I've been told about ${clash.subject} is inconsistent: it's taught to be both `
+            + `${clash.classA} and ${clash.classB}, but ${clash.viaA} and ${clash.viaB} are disjoint (${clash.viaA} owl:disjointWith `
+            + `${clash.viaB}). I'd need one of those retracted before I can answer honestly.`,
+          replace: true,
+        };
+      }
+    }
     // echo the STORED spelling ("caches" asked → "cache" known), never a guess
     const literalHit = hits.find((f) => variants.has(f.subject) || variants.has(f.object));
     const term = literalHit
@@ -3802,6 +4105,46 @@ const OWNS_YESNO_RE = /^(?:does|did)\s+([\w'-]+)\s+(?:owns?|maintains?)\s+(.+?)[
  *  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;
+/** "does/did <N1> have a/an <N2> method" — the HAS-A-METHOD yes/no reader
+ *  (HANDOVER.md 2026-07-10 item 9), sibling of OWNS_YESNO_RE above: mirrors
+ *  TEACH_HAS_METHOD_RE's own subject/capability shape, answering a direct
+ *  yes/no claim against a fact taught via that pattern (mgx:hasA, object
+ *  `"<capability> method"`).
+ *
+ *  NOTE — a real, pre-existing structural collision, confirmed live before
+ *  wiring this: ask.mjs's OWN structural grammar already maps "has"/"have"
+ *  onto the code-graph "defines" relation (ask-vocab.mjs's VERB_TO_KIND), so
+ *  when a real code graph is loaded this EXACT phrasing is parsed there
+ *  FIRST — and because "a <word> method" is separately ambiguous with a
+ *  QUALIFIER reading there ("a public method"), ask.mjs resolves with its own
+ *  (possibly confusing) disambiguation choice, `miss: false`, before this
+ *  reader (factReadBack, gated on `miss` already being true) ever gets a
+ *  turn. Verified live: with a populated code graph, "does Component have a
+ *  render method" always lands on ask.mjs's disambiguation prompt, regardless
+ *  of subject/object identity or any taught fact; with NO code graph loaded
+ *  (this project's other supported mode — a purely conceptual teach-and-
+ *  recall session, see PLAN_TAUGHT_RELATIONS.md's own CONFIG={} test
+ *  convention) ask.mjs's structural attempt declines outright and this reader
+ *  answers correctly. Changing ask.mjs's own qualifier-disambiguation
+ *  behavior is a pre-existing, unrelated structural-grammar concern — out of
+ *  scope for this item.
+ *
+ *  Same "never a guessed no" discipline as IS_ADJECTIVE_YESNO_RE/
+ *  GENERAL_VERB_YESNO_RE below (not OWNS_YESNO_RE's closed-world "no" text):
+ *  a hit answers "yes"; no matching fact DECLINES (null), since "nothing
+ *  taught yet" is not proof the class genuinely lacks the method. */
+const HAS_METHOD_YESNO_RE = /^(?:does|did)\s+([\w'-]+)\s+(?:has|have)\s+an?\s+([a-z][\w-]*)\s+method[?.!\s]*$/i;
+/** "what methods does <N1> have" — the HAS-A-METHOD open-list reader
+ *  (HANDOVER.md 2026-07-10 item 9): the read-back companion to
+ *  HAS_METHOD_YESNO_RE just above — lists every taught mgx:hasA fact for
+ *  <N1> whose object is a "<word> method" phrase. A distinct query shape
+ *  (object noun right after "what", not after the subject), so it does NOT
+ *  share HAS_METHOD_YESNO_RE's own ask.mjs collision: "what methods does X
+ *  have" already reaches an honest `miss: true` from ask.mjs even against a
+ *  populated code graph (confirmed live — "no module matching X found in the
+ *  index" when X isn't a real graph entity), so this reader is reachable in
+ *  both configurations. */
+const HAS_METHOD_OPEN_RE = /^what\s+methods\s+does\s+([\w'-]+)\s+have[?.!\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
@@ -4080,91 +4423,17 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
       // guard is needed at THIS dispatch level (the search kernels
       // underneath — findActionPath — carry their own `seen`-set safety
       // regardless).
-      const resolveRelationChase = async (name, subjectTerm, objectTerm) => {
-        const target = String(name || "").trim().toLowerCase();
-        // (i)+(ii): direct hit or alias-chased hit for this exact (subject,
-        // object) pair under the queried relation name.
-        const sv = factTermVariants(normFactTerm, subjectTerm);
-        const ov = factTermVariants(normFactTerm, objectTerm);
-        const pairHits = relationFactsFor(target).filter((e) => sv.has(e.fact.subject) && ov.has(e.fact.object));
-        if (pairHits.length) {
-          const hit = pairHits.slice().sort((a, b) => byTrust(a.fact, b.fact))[0];
-          return { citation: [renderFactLine(hit.fact), ...hit.aliasFacts.map(
-            (af) => `${factPhrase(af)}${af.provenance ? ` (source: ${af.provenance})` : ""}`,
-          )] };
-        }
-        // The queried name may itself be a taught RULE. findRuleByName is
-        // the SAME lookup §2/§3's own genericity design uses ("what kind of
-        // thing is X") — no per-rule-name branch, just a class/kind check.
-        const {
-          loadMemory, findRuleByName, RULE_KIND_PROP: ruleKindProp,
-          RULE_KIND_COMPOSE2: composeKind, RULE_KIND_FILTER: filterKind,
-        } = await import("./memory/core.mjs");
-        const memory = await loadMemory(memoryDir);
-        const rule = findRuleByName(memory, target);
-        const ruleKind = rule?.attributes?.find((a) => a.prop === ruleKindProp)?.value;
-        // (iii) COMPOSE2 RULE CHASE (Phase 4 item 3) — a hop-counted
-        // findActionPath search over { entity, hopsTaken } states,
-        // dispatching base1's edges at hop 0 and base2's edges at hop 1,
-        // requiring EXACTLY hopsTaken === 2 at the goal — never just
-        // entity === target at any depth.
-        if (rule && ruleKind === composeKind) {
-          const base1 = rule.attributes.find((a) => a.prop === "mgx:ruleBase1")?.value;
-          const base2 = rule.attributes.find((a) => a.prop === "mgx:ruleBase2")?.value;
-          const startEntity = normFactTerm(subjectTerm);
-          const targetEntity = normFactTerm(objectTerm);
-          if (!base1 || !base2 || !startEntity || !targetEntity) return null;
-          const { findActionPath } = await import("./planning.mjs");
-          const applyActions = (state) => {
-            if (state.hopsTaken >= 2) return [];
-            const relName = state.hopsTaken === 0 ? base1 : base2;
-            return relationFactsFor(relName)
-              .filter((e) => e.fact.subject === state.entity)
-              .map((e) => ({ action: e, nextState: { entity: e.fact.object, hopsTaken: state.hopsTaken + 1 } }));
-          };
-          const isGoal = (state) => state.hopsTaken === 2 && state.entity === targetEntity;
-          const stateKey = (state) => `${state.entity}#${state.hopsTaken}`;
-          const found = findActionPath({ entity: startEntity, hopsTaken: 0 }, isGoal, applyActions, { maxDepth: 2, stateKey });
-          if (!found) return null;
-          const seenAlias = new Set();
-          const parts = [];
-          for (const e of found.actions) {
-            parts.push(renderFactLine(e.fact));
-            for (const af of e.aliasFacts) {
-              const key = af.id || `${af.subject}|${af.predicate}|${af.object}`;
-              if (seenAlias.has(key)) continue;
-              seenAlias.add(key);
-              parts.push(`${factPhrase(af)}${af.provenance ? ` (source: ${af.provenance})` : ""}`);
-            }
-          }
-          return { citation: parts };
-        }
-        // (iv) FILTER RULE CHASE (Phase 5 item 4) — recursively resolve the
-        // base (a plain relation OR another rule — this SAME function,
-        // generic over which one it turns out to be), then filter by
-        // whether the SUBJECT carries the property literal
-        // (mgx:hasProperty, a plain Fact lookup over the already-loaded
-        // `rows`). A base chase that fails declines here too (never a
-        // guess); a base chase that succeeds but whose subject lacks the
-        // taught property declines as well — the filter correctly EXCLUDES
-        // that candidate rather than silently ignoring the property clause.
-        if (rule && ruleKind === filterKind) {
-          const base = rule.attributes.find((a) => a.prop === "mgx:ruleBase1")?.value;
-          const property = rule.attributes.find((a) => a.prop === "mgx:ruleFilterProperty")?.value;
-          if (!base || !property) return null;
-          const baseHit = await resolveRelationChase(base, subjectTerm, objectTerm);
-          if (!baseHit) return null;
-          const subjectEntity = normFactTerm(subjectTerm);
-          const propertyNorm = normFactTerm(property);
-          const propHit = rows.find(
-            (f) => f.predicate === HAS_PROPERTY_PREDICATE && f.subject === subjectEntity && normFactTerm(f.object) === propertyNorm,
-          );
-          if (!propHit) return null; // base relation holds, but the property filter excludes this candidate
-          return { citation: [...baseHit.citation, renderFactLine(propHit)] };
-        }
-        return null; // no remembered fact, alias, or rule (of any kind) reaches this
-      };
-      const hit = await resolveRelationChase(relationName, subject, object);
+      // Extracted to memory/core.mjs (PLAN_COMPLETIONS.md Stage 1
+      // prerequisite: cross-group inference reuses this SAME resolution
+      // logic outside chat.mjs's dispatch context) — findRuleByName's own
+      // natural sibling there. `relationFactsFor`/`renderFactLine`/
+      // `factPhrase`/`factTermVariants`/`byTrust`/`rows`/
+      // `HAS_PROPERTY_PREDICATE` are this block's own local closures/
+      // constants, threaded through explicitly rather than re-derived.
+      const { loadMemory, findRuleByName, resolveRelationChase } = await import("./memory/core.mjs");
+      const memory = await loadMemory(memoryDir);
+      const relationChaseHelpers = { relationFactsFor, renderFactLine, factPhrase, factTermVariants, byTrust, rows, HAS_PROPERTY_PREDICATE };
+      const hit = await resolveRelationChase(memory, relationName, subject, object, relationChaseHelpers);
       if (hit) return { text: `yes — ${hit.citation.join("; ")}`, replace: true };
       // Gap 1 fix (live-tested 2026-07-09, PLAN_TAUGHT_RELATIONS.md follow-up):
       // this used to `return null` unconditionally on any miss here — the
@@ -4180,10 +4449,8 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
       // object) pair's chase came up short (e.g. a 2-hop rule with only 1
       // hop of facts taught, or an unrelated pair) — an honest, specific
       // decline that NAMES the relation, never a guessed "no".
-      const { loadMemory: loadMemForMiss, findRuleByName: findRuleByNameForMiss } = await import("./memory/core.mjs");
-      const memoryForMiss = await loadMemForMiss(memoryDir);
       const nameKnown = relationFactsFor(relationName).length > 0
-        || !!findRuleByNameForMiss(memoryForMiss, relationName);
+        || !!findRuleByName(memory, relationName);
       if (!nameKnown) {
         return { text: `I don't know a relation or rule called '${relationName}' yet.`, replace: true };
       }
@@ -4237,10 +4504,7 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
         }
         return out;
       };
-      const {
-        loadMemory: loadMemWho, findRuleByName: findRuleByNameWho, RULE_KIND_PROP: ruleKindPropWho,
-        RULE_KIND_COMPOSE2: composeKindWho, RULE_KIND_FILTER: filterKindWho,
-      } = await import("./memory/core.mjs");
+      const { loadMemory: loadMemWho, findRuleByName: findRuleByNameWho, resolveRelationChaseReverse } = await import("./memory/core.mjs");
       const memoryWho = await loadMemWho(memoryDir);
       // Generic REVERSE relation-NAME resolver — the mirror image of (a0)'s
       // resolveRelationChase: given a relation/rule name and a FIXED OBJECT,
@@ -4249,102 +4513,13 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
       // bounded the SAME way (a0)'s own chase is (§3.3): a filter rule's base
       // is always either a plain relation (terminal) or another rule (one
       // level deeper), never itself.
-      const resolveRelationChaseReverse = async (name, objectTerm) => {
-        const target = String(name || "").trim().toLowerCase();
-        const ov = factTermVariants(normFactTerm, objectTerm);
-        // (i)+(ii): every direct/alias-chased fact under this name whose
-        // object matches the target — one result per distinct subject (the
-        // highest-trust fact when more than one reaches the same subject).
-        const directHits = relationFactsForWho(target).filter((e) => ov.has(e.fact.object));
-        if (directHits.length) {
-          const bySubject = new Map();
-          for (const e of directHits) {
-            if (!bySubject.has(e.fact.subject)) bySubject.set(e.fact.subject, []);
-            bySubject.get(e.fact.subject).push(e);
-          }
-          return [...bySubject.entries()].map(([subj, hits]) => {
-            const hit = hits.slice().sort((a, b) => byTrust(a.fact, b.fact))[0];
-            return {
-              subject: subj,
-              citation: [renderFactLine(hit.fact), ...hit.aliasFacts.map(
-                (af) => `${factPhrase(af)}${af.provenance ? ` (source: ${af.provenance})` : ""}`,
-              )],
-            };
-          });
-        }
-        const rule = findRuleByNameWho(memoryWho, target);
-        const ruleKind = rule?.attributes?.find((a) => a.prop === ruleKindPropWho)?.value;
-        // (iii) COMPOSE2 REVERSE CHASE — the same hop-counted search (a0)'s
-        // forward chase uses, walked BACKWARD: seed from the TARGET object,
-        // reverse-hop via base2's edges first (the SECOND forward hop,
-        // closest to the object), then base1's edges (the FIRST forward
-        // hop) — swapping which side of each fact is queried (object instead
-        // of subject) rather than building a new search kernel. Enumerates
-        // every subject reachable at EXACTLY 2 reverse hops (never just
-        // "reachable within budget" — the same exact-hop-count discipline
-        // (a0)'s own isGoal uses), via findReachableSet (already proven
-        // cycle-safe by item 6's own reachability-list wiring, (a0.5) below).
-        if (rule && ruleKind === composeKindWho) {
-          const base1 = rule.attributes.find((a) => a.prop === "mgx:ruleBase1")?.value;
-          const base2 = rule.attributes.find((a) => a.prop === "mgx:ruleBase2")?.value;
-          const targetEntity = normFactTerm(objectTerm);
-          if (!base1 || !base2 || !targetEntity) return [];
-          const { findReachableSet: findReachableSetWho } = await import("./planning.mjs");
-          const applyActionsRev = (state) => {
-            if (state.hopsTaken >= 2) return [];
-            const relName = state.hopsTaken === 0 ? base2 : base1;
-            return relationFactsForWho(relName)
-              .filter((e) => e.fact.object === state.entity)
-              .map((e) => ({ action: e, nextState: { entity: e.fact.subject, hopsTaken: state.hopsTaken + 1 } }));
-          };
-          const stateKeyRev = (state) => `${state.entity}#${state.hopsTaken}`;
-          const reached = findReachableSetWho(
-            { entity: targetEntity, hopsTaken: 0 }, applyActionsRev, { maxDepth: 2, stateKey: stateKeyRev },
-          );
-          return reached.filter((r) => r.node.hopsTaken === 2).map(({ node, path }) => {
-            const seenAlias = new Set();
-            const parts = [];
-            // path.actions was accumulated walking BACKWARD from the object
-            // (base2's edge first, base1's edge second) — reversed here so
-            // the citation reads in the natural subject-to-object order
-            // ("ahab fathers john; …; john fathers ishmael"), matching (a0)'s
-            // own forward-chase citation order rather than exposing the
-            // reverse-walk's internal accumulation order to the user.
-            for (const e of path.actions.slice().reverse()) {
-              parts.push(renderFactLine(e.fact));
-              for (const af of e.aliasFacts) {
-                const key = af.id || `${af.subject}|${af.predicate}|${af.object}`;
-                if (seenAlias.has(key)) continue;
-                seenAlias.add(key);
-                parts.push(`${factPhrase(af)}${af.provenance ? ` (source: ${af.provenance})` : ""}`);
-              }
-            }
-            return { subject: node.entity, citation: parts };
-          });
-        }
-        // (iv) FILTER REVERSE CHASE — reverse-chase the base (recursively,
-        // same as the forward filter chase — this SAME function calls
-        // itself), then filter the resulting subjects by whether EACH
-        // carries the taught property.
-        if (rule && ruleKind === filterKindWho) {
-          const base = rule.attributes.find((a) => a.prop === "mgx:ruleBase1")?.value;
-          const property = rule.attributes.find((a) => a.prop === "mgx:ruleFilterProperty")?.value;
-          if (!base || !property) return [];
-          const baseHits = await resolveRelationChaseReverse(base, objectTerm);
-          const propertyNorm = normFactTerm(property);
-          const out = [];
-          for (const bh of baseHits) {
-            const subjectEntity = normFactTerm(bh.subject);
-            const propHit = rows.find(
-              (f) => f.predicate === HAS_PROPERTY_PREDICATE && f.subject === subjectEntity && normFactTerm(f.object) === propertyNorm,
-            );
-            if (propHit) out.push({ subject: bh.subject, citation: [...bh.citation, renderFactLine(propHit)] });
-          }
-          return out;
-        }
-        return []; // no remembered fact, alias, or rule (of any kind) reaches this
-      };
-      const hits = await resolveRelationChaseReverse(relationName, object);
+      // Extracted to memory/core.mjs alongside (a0)'s own resolveRelationChase
+      // (PLAN_COMPLETIONS.md Stage 1 prerequisite — see (a0)'s own comment for
+      // why); `relationFactsForWho`/`renderFactLine`/`factPhrase`/
+      // `factTermVariants`/`byTrust`/`rows`/`HAS_PROPERTY_PREDICATE` are this
+      // block's own local closures/constants, threaded through explicitly.
+      const relationChaseHelpersWho = { relationFactsFor: relationFactsForWho, renderFactLine, factPhrase, factTermVariants, byTrust, rows, HAS_PROPERTY_PREDICATE };
+      const hits = await resolveRelationChaseReverse(memoryWho, relationName, object, relationChaseHelpersWho);
       if (hits.length) {
         const lines = hits.map((h) => `${h.subject} — ${h.citation.join("; ")}`);
         return { text: lines.join("\n"), replace: true };
@@ -4357,8 +4532,15 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
       if (!nameKnownWho) {
         return { text: `I don't know a relation or rule called '${relationName}' yet.`, replace: true };
       }
+      // HANDOVER.md 2026-07-10 item 3: "what is the capital of france" reads
+      // oddly as "I don't know ANYONE who is the capital…" — the neutral
+      // "nothing/anyone" split below matches whichever interrogative word the
+      // query actually used.
+      const isWhatAsk = /^what\b/i.test(qHedge);
       return {
-        text: `I don't know anyone who is the ${relationName} of ${object} from what you've told me.`,
+        text: isWhatAsk
+          ? `I don't know what the ${relationName} of ${object} is from what you've told me.`
+          : `I don't know anyone who is the ${relationName} of ${object} from what you've told me.`,
         replace: true,
       };
     }
@@ -4462,9 +4644,20 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
   // (a) FORWARD membership — "is an X a Y". X's fact-subject candidates are the
   // term itself (a class word) AND, when it resolves in the graph, its class-noun
   // (an instance) — so "is app/lib/a.mjs a component" answers off "module …".
-  const isaAsk = q.match(ISA_ASK_RE);
+  // A confirmation-check wrapper ("so X is a Y now right?") is rewritten to the
+  // plain "is X a Y" form and re-tried when the raw query itself doesn't match —
+  // see CONFIRM_TAG_RE's own docblock.
+  const confirmTag = q.match(CONFIRM_TAG_RE);
+  const isaAsk = q.match(ISA_ASK_RE) || (confirmTag && `is ${confirmTag[1].trim()} a ${confirmTag[2].trim()}`.match(ISA_ASK_RE));
   if (isaAsk) {
-    const objVariants = factTermVariants(normFactTerm, isaAsk[2]);
+    // Playtest sprint round 1 (2026-07-10): "is TaskController a validator then"
+    // — the same trailing bare discourse tag item 8 fixed for metaTermOf's bare
+    // "what is X" shape also glues onto ISA_ASK_RE's captured kind term (its own
+    // trailing anchor only allows punctuation/whitespace, not a stray word), so
+    // "validator then" never matched any taught fact even though the CLASS↔
+    // INSTANCE BRIDGE below would otherwise answer yes. Same stripTrailingDiscourseTag
+    // fix, applied here too.
+    const objVariants = factTermVariants(normFactTerm, stripTrailingDiscourseTag(isaAsk[2]));
     const subjCandidates = new Set(factTermVariants(normFactTerm, isaAsk[1]));
     const noun = await entityClassNoun(graph, isaAsk[1]);
     if (noun) for (const v of factTermVariants(normFactTerm, noun)) subjCandidates.add(v);
@@ -4529,6 +4722,73 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
       const premises = chain.map(factForStep);
       if (premises.every(Boolean)) return { text: `yes — ${renderIsaChain(premises)}`, replace: true };
     }
+    // LIVE cax-dw PROOF CHASE (PLAN_INFERENCE_TESTING.md INF-B1, §4 stage 3):
+    // every "yes" strategy above missed — check whether X's taught type
+    // (lifted through its FULL ⊑-ancestor closure) is disjointWith the
+    // queried class, via syllogise.mjs's deriveDisjointViolations, LIVE and
+    // READ-ONLY (same discipline as the findIsaChain chase just above:
+    // nothing is written; syllogise()'s materializing batch pass is the
+    // persisting counterpart of this same rule, never on the chat hot path).
+    // A hit here is a PROVABLE "no" — the one shape on this ladder allowed to
+    // answer "no" from absence-of-membership rather than decline; anything
+    // this chase can't connect through a stated disjointness falls through
+    // to the honest miss below, never a guessed "no".
+    const { deriveDisjointViolations, DISJOINT_PREDICATE } = await import("./syllogise.mjs");
+    const disjointRows = rows.filter((f) => f.predicate === DISJOINT_PREDICATE && isTaught(f));
+    if (disjointRows.length) {
+      const disjointEdges = disjointRows.map((f) => [f.subject, f.object]);
+      const violations = deriveDisjointViolations(chainTypeEdges, chainSubClassEdges, disjointEdges, { budget: 10 });
+      for (const subj of subjCandidates) {
+        const v = violations.find((vv) => vv.subject === subj && objVariants.has(vv.object));
+        if (!v) continue;
+        const typeFact = chainTypeRows.find((f) => f.subject === v.subject && f.object === v.viaType);
+        const disjointFact = disjointRows.find((f) => (f.subject === v.viaClass && f.object === v.object)
+          || (f.subject === v.object && f.object === v.viaClass));
+        const parts = [typeFact, disjointFact].filter(Boolean).map(renderFactLine);
+        return { text: `no — ${parts.length ? parts.join("; ") : `${v.viaClass} and ${v.object} are disjoint.`}`, replace: true };
+      }
+    }
+    // LIVE cls-svf1 PROOF CHASE (HANDOVER.md 2026-07-10 item 4,
+    // PLAN_INFERENCE_TESTING.md INF-B2, §4 stage 4): every strategy above
+    // missed — check whether X, having taught-P'd something of a taught type
+    // (lifted through that type's FULL ⊑-ancestor closure), satisfies a
+    // TAUGHT someValuesFrom restriction declared over that SAME (property,
+    // type) pair — the restriction CLASS itself entailed (OWL 2 RL Table 8's
+    // cls-svf1), via syllogise.mjs's deriveSomeValuesFromApplication, LIVE and
+    // READ-ONLY (same discipline as the cax-dw chase just above: nothing is
+    // written; syllogise()'s materializing batch pass is the persisting
+    // counterpart of this same rule). The restriction's own scaffolding
+    // (owl:onProperty/owl:someValuesFrom) and every property/type premise must
+    // all be TAUGHT (never corpus-sourced), same as every other live chase in
+    // this block.
+    const { deriveSomeValuesFromApplication, ON_PROPERTY_PREDICATE, SOME_VALUES_FROM_PREDICATE } = await import("./syllogise.mjs");
+    const onPropertyRows = rows.filter((f) => f.predicate === ON_PROPERTY_PREDICATE && isTaught(f));
+    const someValuesFromRows = rows.filter((f) => f.predicate === SOME_VALUES_FROM_PREDICATE && isTaught(f));
+    if (onPropertyRows.length && someValuesFromRows.length) {
+      const someValuesFromOf = new Map(someValuesFromRows.map((f) => [f.subject, f.object]));
+      const restrictionEdges = onPropertyRows
+        .map((f) => ({ restriction: f.subject, property: f.object, target: someValuesFromOf.get(f.subject) }))
+        .filter((r) => r.target);
+      // Every OTHER taught object-property assertion is a candidate premise —
+      // never hard-coded to one verb, mirroring syllogise()'s own generic
+      // propertyEdges scan (RESERVED_PREDICATES, syllogise.mjs) minus the
+      // predicates the other rules on this ladder already own.
+      const svf1Reserved = new Set([SC_PREDICATE, RDF_TYPE_PREDICATE, DISJOINT_PREDICATE, ON_PROPERTY_PREDICATE, SOME_VALUES_FROM_PREDICATE, "owl:intersectionOf"]);
+      const propertyRows = rows.filter((f) => isTaught(f) && !svf1Reserved.has(f.predicate));
+      const propertyEdges = propertyRows.map((f) => [f.subject, f.predicate, f.object]);
+      const svf1Derived = deriveSomeValuesFromApplication(propertyEdges, chainTypeEdges, chainSubClassEdges, restrictionEdges, { budget: 10 });
+      for (const subj of subjCandidates) {
+        const hit = svf1Derived.find((d) => d.subject === subj && objVariants.has(d.object));
+        if (!hit) continue;
+        const propFact = propertyRows.find((f) => f.subject === hit.subject && f.predicate === hit.viaProperty && f.object === hit.viaValue);
+        const typeFact = chainTypeRows.find((f) => f.subject === hit.viaValue && f.object === hit.viaType);
+        const parts = [propFact, typeFact].filter(Boolean).map(renderFactLine);
+        return {
+          text: `yes — ${parts.length ? parts.join("; ") : `${hit.subject} ${hit.viaProperty} ${hit.viaValue}, and ${hit.viaValue} is a ${hit.viaType}.`}`,
+          replace: true,
+        };
+      }
+    }
     return null; // no remembered fact — the honest miss stands (never a guessed "no")
   }
 
@@ -4595,6 +4855,39 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
     };
   }
 
+  // (a2b-iii) HAS-A-METHOD yes/no — "does/did <N1> have a/an <N2> method"
+  // (HANDOVER.md 2026-07-10 item 9): see HAS_METHOD_YESNO_RE's own docblock
+  // for the full design, including the confirmed pre-existing ask.mjs
+  // structural collision when a real code graph is loaded. A hit answers
+  // "yes"; no matching fact DECLINES (null) — never a guessed "no" (this
+  // reader follows IS_ADJECTIVE_YESNO_RE/GENERAL_VERB_YESNO_RE's OWA
+  // discipline below, not OWNS_YESNO_RE's closed-world "no" just above).
+  const hasMethodYN = qHedge.match(HAS_METHOD_YESNO_RE);
+  if (hasMethodYN) {
+    const [, subjRaw, capRaw] = hasMethodYN;
+    const subjVariants = factTermVariants(normFactTerm, subjRaw.trim());
+    const objVariants = factTermVariants(normFactTerm, `${capRaw.trim()} method`);
+    const hit = rows
+      .filter((f) => f.predicate === HAS_A_PREDICATE && subjVariants.has(f.subject) && objVariants.has(f.object))
+      .sort(byTrust)[0];
+    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    return null; // no remembered fact — honest decline, never a guessed "no"
+  }
+
+  // (a2b-iv) HAS-A-METHOD open list — "what methods does <N1> have"
+  // (HANDOVER.md 2026-07-10 item 9): every taught mgx:hasA fact for <N1>
+  // whose object is a "<word> method" phrase. An honest empty (null, never a
+  // guessed method name) when nothing was taught for this subject.
+  const hasMethodOpen = qHedge.match(HAS_METHOD_OPEN_RE);
+  if (hasMethodOpen) {
+    const subjVariants = factTermVariants(normFactTerm, hasMethodOpen[1].trim());
+    const hits = rows
+      .filter((f) => f.predicate === HAS_A_PREDICATE && subjVariants.has(f.subject) && / method$/.test(f.object))
+      .sort(byTrust);
+    if (!hits.length) return null;
+    return renderMany(hits);
+  }
+
   // (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
@@ -4613,6 +4906,30 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
     const adjective = isAdj[2].trim().toLowerCase();
     if (subject) {
       const subjVariants = factTermVariants(normFactTerm, subject);
+      // CLASS↔INSTANCE BRIDGE (playtest sprint round 2, 2026-07-10): "is Task
+      // auditable" used to say "I don't know anything about Task yet" even
+      // with "every Record is auditable" taught and Task inheriting Record in
+      // the code graph — this property-yes/no reader had no inheritance
+      // bridging at all, unlike isaAsk's own CLASS↔INSTANCE BRIDGE just above
+      // (chat.mjs's `inheritsChain`). Same bridge, same discipline: when the
+      // subject resolves to a real graph entity, its superclass LABELS are
+      // ADDITIONAL subject candidates, so a taught property on an ancestor
+      // class is found too — never a guess, still just a direct fact lookup,
+      // now over a wider (but still fact-backed) candidate set.
+      const bridgeSubjects = new Map(); // fact-term variant → superclass label, as spelled in the graph
+      let bridgeEnt = null;
+      if (graph) {
+        const ent = await resolveEntity(graph, subject);
+        bridgeEnt = ent;
+        if (ent) {
+          for (const sup of inheritsChain(graph, ent.id)) {
+            for (const v of factTermVariants(normFactTerm, sup.label)) {
+              if (!subjVariants.has(v) && !bridgeSubjects.has(v)) bridgeSubjects.set(v, sup.label);
+              subjVariants.add(v);
+            }
+          }
+        }
+      }
       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"
@@ -4625,7 +4942,17 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
       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 };
+      if (hit) {
+        const viaSuper = bridgeSubjects.get(hit.subject);
+        // Named explicitly (never a silent subject swap) — same honesty
+        // discipline isaAsk's own class↔instance bridge follows just above.
+        return {
+          text: viaSuper
+            ? `yes — the code graph says ${bridgeEnt.label} inherits ${viaSuper}, and ${renderFactLine(hit)}`
+            : `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
@@ -5061,14 +5388,16 @@ const BARE_WHATIS_RE = /^what\s+(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
  *  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. */
+ *  cover this function's own regex fallback. HANDOVER.md 2026-07-10 item 8: a
+ *  trailing bare discourse tag ("what is a component THEN") is stripped the same
+ *  way (stripTrailingDiscourseTag) before the scope-filler strip. */
 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 ? stripTrailingScopeFiller(m[1].trim()) : null;
+  return m ? stripTrailingScopeFiller(stripTrailingDiscourseTag(m[1].trim())) : null;
 }
 
 /** The TEACH-OFFER line for a term that's genuinely unknown everywhere (Tier-5
@@ -5380,6 +5709,14 @@ async function describeWrapperAnswer(query, { config, source, focus, graph, tel
   const m = DESCRIBE_WRAPPER_RE.exec(q) || STACCATO_PRONOUN_RE.exec(q);
   let term = m?.[1]?.trim();
   if (!term) return null;
+  // HANDOVER.md 2026-07-10 item 10: "describe about X" (a doubled verb — the
+  // "describe" branch of DESCRIBE_WRAPPER_RE never expects a following "about",
+  // unlike its own "tell me about"/"what about" branches, which already consume
+  // theirs inside the regex) leaves a redundant leading "about " glued to the
+  // captured term. Stripped once, here, before any resolution — the other two
+  // branches never leave this residue, so this can only ever help the doubled-
+  // verb case, never change a correctly-captured term.
+  term = term.replace(/^about\s+/i, "");
   if (DESCRIBE_PRONOUN_RE.test(term)) {
     if (!focus?.label) return null; // no standing focus to resolve against — honest decline
     term = focus.label;
@@ -5407,6 +5744,84 @@ async function describeWrapperAnswer(query, { config, source, focus, graph, tel
   }
 }
 
+/** DETAILED-SUMMARY / EXPLAIN-IN-DETAIL closed phrasings (HANDOVER.md 2026-07-10 item
+ *  7) — "give me a detailed summary of how the task system works" / "explain in detail
+ *  how X works" / "give me a detailed overview of X". PLAYTESTBENCH_1.4.1.md round 3
+ *  caught this EXACT phrasing hitting the plain grammar wall with NO inferred goal at
+ *  all, even though src/completions/'s extractive multi-sentence pipeline (Stages 0-3,
+ *  built and unit-tested the same session) already existed and could answer it when
+ *  called directly — it was simply unreachable from any real chat turn.
+ *
+ *  Two closed shapes, deliberately narrow (this project's own discipline: curated
+ *  closed patterns, never a general "any long question" catch-all):
+ *   1. DETAILED_HOW_WORKS_RE — "...detailed (summary|overview|explanation) of how X
+ *      works" / "explain ... in detail how X works" — the "how X works" shape
+ *      PLAYTESTBENCH's own probe used. Tried FIRST (its "works" anchor is strictly
+ *      more specific, so it must win over #2 whenever both could parse).
+ *   2. DETAILED_OVERVIEW_RE — "...detailed (overview|summary|explanation) of X" — the
+ *      bare-subject sibling, no "how...works" wrapper.
+ *  Distinct from DESCRIBE_WRAPPER_RE (a single-answer "one definition" lane, anchored
+ *  on "tell me about"/"describe"/"what about") — neither of these two anchors on
+ *  "give me"/"explain ... in detail", so there is no overlap to shadow. */
+const DETAILED_HOW_WORKS_RE =
+  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?(?:give\s+me\s+a\s+detailed\s+(?:summary|overview|explanation)\s+of\s+how|explain\s+(?:to\s+me\s+)?in\s+detail\s+how)\s+(.+?)\s+works\s*\??$/i;
+
+const DETAILED_OVERVIEW_RE =
+  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?give\s+me\s+a\s+detailed\s+(?:overview|summary|explanation)\s+of\s+(.+?)\s*\??$/i;
+
+/** THE COMPLETIONS RESCUE (HANDOVER.md 2026-07-10 item 7) — wires src/completions/'s
+ *  extractive, cited, groundedness-checked multi-sentence pipeline (generateCompletion(),
+ *  src/completions/complete.mjs) into live chat dispatch. Tried in runAsk ONLY after
+ *  (4d) DESCRIBE-WRAPPER RESCUE (and everything above it) has already declined — the
+ *  same "last-resort lane" discipline synonymFactAnswer's and describeWrapperAnswer's
+ *  own docblocks each spell out: "describe X" / "tell me about X" phrasings must keep
+ *  reaching describeWrapperAnswer's (or the relation force's) single-answer rescue
+ *  unmolested; this lane only ever claims a turn shaped as an EXPLICIT request for a
+ *  detailed/multi-sentence account (DETAILED_HOW_WORKS_RE / DETAILED_OVERVIEW_RE,
+ *  above), a shape neither DESCRIBE_WRAPPER_RE nor vagueTouchTermOf recognizes.
+ *
+ *  Honest by construction: generateCompletion() itself declines (returns
+ *  `declined:true`, empty text) whenever nothing in the corpus/graph clears its own
+ *  pruning bar for the term (PLAN_COMPLETIONS.md §3's honest ceiling) — this lane
+ *  passes that decline straight through as null, falling through to the ordinary miss
+ *  below. NEVER fabricates. Lazy + failure-tolerated (dynamic import, try/catch) like
+ *  every other lane in this file. src/completions/ itself is untouched by this change —
+ *  this is the call site only. */
+async function completionsRescueAnswer(query, { memoryDir, graph }) {
+  if (!memoryDir) return null; // no repo/memory to search — honest decline
+  // Deliberately NOT applyPreambleFrames here (unlike describeWrapperAnswer just
+  // above) — found live while wiring this lane: its own SHOW_GIVE_ME_RE frame turns
+  // ANY "give me (the)? X" into "describe X" before this lane would ever see it,
+  // which is exactly right for describeWrapperAnswer (DESCRIBE_WRAPPER_RE has its own
+  // "describe " branch to catch that) but SILENTLY DESTROYS this lane's own
+  // "give me a detailed summary/overview of ..." anchor — "give me a detailed summary
+  // of how the Widget works" became "describe a detailed summary of how the Widget
+  // works" and neither DETAILED_HOW_WORKS_RE nor DETAILED_OVERVIEW_RE could match it
+  // anymore, so the turn silently fell through to the plain grammar wall exactly like
+  // before this lane existed. Matching the RAW trimmed query instead is safe: this
+  // lane's own two regexes already carry their own optional "can/could/would you
+  // (please)?"/"please" politeness prefix (mirroring DESCRIBE_WRAPPER_RE's own), so no
+  // separate normalization pass is needed for the phrasings this lane targets.
+  const q = String(query || "").trim();
+  const m = DETAILED_HOW_WORKS_RE.exec(q) || DETAILED_OVERVIEW_RE.exec(q);
+  let term = m?.[1]?.trim();
+  if (!term) return null;
+  // same bare-article strip describeWrapperAnswer's resolveSymbol-facing branch
+  // already uses just above — pure retrieval/ranking noise, never a real content
+  // signal, and stripping it only ever REMOVES characters, never changes a
+  // correctly-captured term.
+  term = term.replace(/^(?:the|a|an)\s+/i, "").trim();
+  if (!term) return null;
+  try {
+    const { generateCompletion } = await import("./completions/complete.mjs");
+    const result = await generateCompletion(memoryDir, term, { query: term, graph });
+    if (!result || result.declined || !result.text) return null; // honest decline — never fabricate
+    return { text: result.text };
+  } catch {
+    return null; // unresolvable/errored — decline, the ordinary wall stands unchanged
+  }
+}
+
 /** THE RELATION CONCEPT FORCE — compose the three-band answer (curated relation
  *  definition + real example EDGES + pre-validated follow-ups) for a vague touch on a
  *  relation/edge kind ("what about imports", "what are the calls", "tell me about
@@ -5869,9 +6284,43 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   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 && (bareWhatisShape || isAdjectiveShape)) {
-    bareMetaHit = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle))
-      ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle));
+  if (isConversationalCandidate && (bareWhatisShape || isAdjectiveShape)) {
+    if (memoryDir) {
+      bareMetaHit = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle))
+        ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle));
+      // HANDOVER.md 2026-07-10 item 10 (dropped-article gap): a bare "what is X"
+      // with NO taught fact but a KNOWN curated corpus term ("what is cache", no
+      // article) used to lose this exact same isConversationalCandidate race —
+      // curatedDefinitionAnswer was only ever reached once the article made T5's
+      // structural parse succeed (envelope.parsed non-null), never on the bare
+      // form. Same "only diverts on a REAL hit" discipline as the rest of this
+      // lane — an unknown bare term still falls through to the ordinary
+      // orientation card, exactly as before.
+      if (!bareMetaHit) {
+        const def = await curatedDefinitionAnswer(query, envelope, { memoryDir, lexicon });
+        if (def) bareMetaHit = { text: def.text, replace: true };
+      }
+    }
+    // HANDOVER.md 2026-07-10 item 6 (CHATBENCH g-a2-naming-2: "what is Widget",
+    // no article): a bare "what is X" naming a REAL code-graph entity (Class/
+    // Function/Method/GlobalVariable/Attribute — not a taught fact, not a
+    // curated corpus term) lost this SAME isConversationalCandidate race too.
+    // metaFallbackEntityAnswer (ask.mjs) is the exact fallback the ARTICLED
+    // form's structural parse already reaches once T5 succeeds; tried here so
+    // the bare form gets the byte-identical answer, never a worse one just
+    // because it dropped the article. Deliberately OUTSIDE the `memoryDir`
+    // check above — this is a pure graph lookup, no memory/Facts access
+    // needed, and CHATBENCH's own "turns" replay mode drives runTurn with a
+    // graph but no memoryDir at all, so gating this on memoryDir too would
+    // silently never fire in the one harness this fix specifically targets.
+    if (!bareMetaHit && graph) {
+      const term = metaTermOf(query, envelope);
+      if (term) {
+        const { metaFallbackEntityAnswer } = await import("./ask.mjs");
+        const fallback = metaFallbackEntityAnswer(graph, term);
+        if (fallback) bareMetaHit = { text: fallback.text, replace: true };
+      }
+    }
   }
   if (bareMetaHit) {
     answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
@@ -6122,6 +6571,26 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       note(trace, "goal: get a symbol's definition/kind/relations (phrased conversationally)");
     }
   }
+  // (4e) COMPLETIONS RESCUE (HANDOVER.md 2026-07-10 item 7) — wires src/completions/'s
+  // extractive multi-sentence pipeline in as a genuine last-resort lane, tried ONLY
+  // here, after EVERY lane above (including (4d) DESCRIBE-WRAPPER RESCUE) has already
+  // declined — "describe X"/"tell me about X" must keep reaching describeWrapperAnswer's
+  // (or the relation force's) single-answer rescue unmolested; this lane only fires for
+  // an EXPLICIT "detailed summary/overview of how X works" phrasing
+  // (DETAILED_HOW_WORKS_RE/DETAILED_OVERVIEW_RE), a shape neither DESCRIBE_WRAPPER_RE
+  // nor vagueTouchTermOf recognizes. PLAYTESTBENCH_1.4.1.md round 3's own
+  // architecturally-confirmed gap: this exact phrasing hit the plain grammar wall with
+  // no inferred goal at all, even though the pipeline that could answer it already
+  // existed — it was simply unreachable from any real chat turn.
+  if (miss && recordMiss && via === "composed") {
+    const completed = await completionsRescueAnswer(query, { memoryDir, graph });
+    if (completed) {
+      answer = completed.text; via = "completion"; recordMiss = false;
+      note(trace, "lane: (4e) COMPLETIONS RESCUE — a \"detailed summary/overview of how X works\" phrasing matched, answered via src/completions/'s extractive multi-sentence pipeline (generateCompletion())");
+      note(trace, "source: src/completions/complete.mjs generateCompletion() (broadSearch + groupHits + rankSentences + inferRelations + pruneCompletion + finish())");
+      note(trace, "goal: produce a grounded, cited, multi-sentence account of the subject (not a single fact/definition)");
+    }
+  }
   // (5) #1 SHORT TAILORED MISS — replace ONLY the engine's full grammar cheat-sheet
   // wall (WALL_MISS_RE). Receipt-bearing misses keep their specific wording.
   // WALL KINDNESS (0.8.2 WS4 (a)): when the PREVIOUS turn's answer was already a