@polycode-projects/the-mechanical-code-talker 0.9.11 → 1.0.0

package/src/chat.mjs

@@ -51,9 +51,10 @@ import { uuidv7 } from "./uuid.mjs";
 import { createTelemetry } from "./telemetry.mjs";
 import * as defaultSource from "./source.mjs";
 import { loadTemplates, render as renderTemplate } from "./corpus/templates.mjs";
-import { finish } from "./finish.mjs";
-import { VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE } from "./ask-vocab.mjs";
-import { COUNTERFACTUAL_RE } from "./interpret/normalize.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 { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames } from "./interpret/normalize.mjs";
+import { fuzzyMatchInSet, fuzzyBound } from "./interpret/fuzzy.mjs";
 
 // uuidv7 lives in ./uuid.mjs (shared with telemetry + the bench stamp); re-exported
 // here because callers/tests still import it from chat.mjs.
@@ -332,6 +333,14 @@ export function asBareCommand(line) {
   // unconditionally): the predicate-find grammar's own shape wins regardless of
   // word count, see the precedence note above.
   if (fl === "find" && looksLikePredicateFind(restTok)) return null;
+  // "describe it"/"describe that" (0.9.13 Tier-1 playtest): a bare PRONOUN argument
+  // to /describe has no antecedent at this layer — dispatchTool("tmct_describe", …)
+  // does its own name-only resolveSymbol lookup with no notion of the standing
+  // focus, so routing it here as a bare command produced a raw "no such symbol"
+  // failure. Defer to the ordinary pipeline instead (return null): it reaches
+  // describeWrapperAnswer's rescue lane, which DOES resolve a bare pronoun against
+  // the standing focus. A named argument ("describe Widget") is untouched.
+  if (fl === "describe" && DESCRIBE_PRONOUN_RE.test(rest)) return null;
   // A NO-ARGUMENT command word ("untested") with trailing words is NOT a command
   // call — the /untested tool takes no argument and would silently drop the qualifier,
   // listing MODULES for "untested classes". "untested classes" / "untested modules"
@@ -385,9 +394,72 @@ function countableKinds(graph) {
  *  by the ask engine's anaphora node, never the header-count path. */
 const ANAPHORA_COUNT_RE = /\b(?:how many|how much|count|number of)\s+(?:of\s+)?(?:those|them|these)\b/i;
 
+/** An IMPLICIT anaphoric count with NO explicit "of them/those/these" at all —
+ *  "how many are tested", "and how many are tested" (Tier-2 playtest, 5th
+ *  pass). A fluent staccato follow-up after a just-given list naturally elides
+ *  the pronoun a fuller phrasing ("how many of those are tested") carries —
+ *  ANAPHORA_COUNT_RE above requires that explicit "of them/those/these" and
+ *  never fires for this shape, so answerCount's own bare noun-scan greedily
+ *  (and wrongly) captured the linking verb ITSELF as the counted noun ("how
+ *  many ARE tested" -> noun="are") and answered the nonsensical "I can't
+ *  count 'are'." Gated on real content after the linking verb (`(?!there\b)`)
+ *  so a genuinely bare "how many are there" (no antecedent, no predicate to
+ *  filter on) is untouched — that one's existing "I can't count 'are'" nudge
+ *  is arguably the more honest answer to a query naming nothing at all. */
+const IMPLICIT_ANAPHORA_COUNT_RE = /^(?:(?:and|so|then|also)\s+)?how many (?:are|is|were|was)\s+(?!there\b)(\S.*)$/i;
+
+/** "have"/"has"/"holds"/"hold" are excluded from RESTRICTOR_VERB_RE below —
+ *  DELIBERATELY treated as non-restrictor cues here, not a bug fix skipped. Ask-
+ *  vocab's VERB_TO_KIND maps them to "defines" unconditionally, but the graph's
+ *  actual "have" semantics are subject-type-dependent (a Module "has" things it
+ *  defines; a Class "has" things it contains) — found live (0.9.14 Tier-2 playtest,
+ *  third pass, numeric/quantifier relation touches) that ask.mjs's own engine
+ *  resolves the two surface forms of the SAME query ("what methods does Widget
+ *  have" vs "which methods does Widget have") to DIFFERENT, inconsistent kinds (one
+ *  correctly reaches "contains", the other wrongly reaches "defines" and returns an
+ *  honest-but-wrong zero) — a genuine, pre-existing ambiguity in the core clause
+ *  grammar, orthogonal to dialogue flow/routing and out of this cycle's scope.
+ *  Deferring a "have" tail to the ask engine here would just trade one wrong-answer
+ *  risk for another rather than fixing anything, so it stays on the existing
+ *  bare-count path (unchanged behavior, no new regression) until a dedicated fix
+ *  teaches the grammar to pick "defines" vs "contains" by the resolved subject's
+ *  own class. */
+const AMBIGUOUS_HAVE_VERBS = new Set(["have", "has", "holds", "hold"]);
+
+/** A "how many <kind> …" tail carries a genuine RESTRICTOR clause — not filler — iff
+ *  it names a real relation verb (active, from VERB_TO_KIND, or passive-participle,
+ *  from PASSIVE_PARTICIPLE_TO_KIND — both ask-vocab.mjs's closed vocabulary, the
+ *  same one ask.mjs's own clause grammar reads), minus the ambiguous "have" family
+ *  above. Matching on the VERB specifically (not "any non-stopword word") matters:
+ *  a tail's own OBJECT NAME is also non-stopword content ("how many methods does
+ *  WIDGET have" — "Widget" alone isn't a restrictor cue), so a bare
+ *  content-word test would misfire on every qualified count regardless of verb. */
+const RESTRICTOR_VERB_RE = new RegExp(
+  `\\b(?:${
+    [...Object.keys(VERB_TO_KIND), ...Object.keys(PASSIVE_PARTICIPLE_TO_KIND)]
+      .filter((v) => !AMBIGUOUS_HAVE_VERBS.has(v))
+      .sort((a, b) => b.length - a.length)
+      .map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+      .join("|")
+  })\\b`,
+  "i",
+);
+
 /** Recognise a count/aggregate question and answer it from the graph header, or
  *  null if it isn't one (→ fall through to tmct_ask). "how many X [are there]",
- *  "count [the] X", "number of X". An unknown kind lists what it CAN count. */
+ *  "count [the] X", "number of X". An unknown kind lists what it CAN count.
+ *
+ *  A RESTRICTOR tail ("how many modules IMPORT app/lib/a.mjs", "how many classes
+ *  INHERIT FROM Base") is NOT a bare header count — found live (0.9.14 Tier-2
+ *  playtest, third pass, numeric/quantifier relation touches): this regex only ever
+ *  captured the noun immediately after "how many" and silently discarded everything
+ *  after it, so a qualified count fell back to the UNQUALIFIED class total ("how many
+ *  modules import app/lib/a.mjs" answered "8 modules" — the whole-graph module count —
+ *  instead of the 3 that actually import it). ask.mjs's own AGGREGATE node
+ *  (parseAggregate) already evaluates a restrictor tail correctly via parseSetPhrase,
+ *  so once the tail names a real relation verb (RESTRICTOR_VERB_RE), decline here and
+ *  let the turn fall through to the real ask engine instead of returning a misleading
+ *  bare total. */
 export function answerCount(graph, query) {
   if (!graph) return null;
   // ANAPHORIC counts ("how many of those are tested", "count them", "how many of
@@ -396,10 +468,15 @@ export function answerCount(graph, query) {
   // this the bare "of"/pronoun head is mis-reported as an uncountable kind and the
   // discourse+count follow-up dies before it can resolve (CHATBENCH_006 lever 1).
   if (ANAPHORA_COUNT_RE.test(String(query))) return null;
+  // The elliptical sibling above (no explicit "of them/those" at all) — same
+  // decline, same reason: this is a reference to the PREVIOUS answer's set,
+  // not a graph kind named "are"/"is"/"were"/"was".
+  if (IMPLICIT_ANAPHORA_COUNT_RE.test(String(query).trim())) return null;
   const m = String(query).match(/\b(?:how many|number of|count(?:\s+the)?)\s+([a-z]+)\b/i);
   if (!m) return null;
   const noun = m[1].toLowerCase();
   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(", ")}. ` +
       `Try "how many classes are there".`;
@@ -497,15 +574,54 @@ export function renderStats(graph) {
 
 // ---- friendly handling of non-structural / conversational input ----
 
-/** Greetings and small-talk openers that should get a friendly orientation line,
- *  never the raw grammar-miss hint. */
-const GREETINGS = new Set([
-  "hi", "hello", "hey", "yo", "sup", "hiya", "howdy", "hey there", "hi there", "hello there",
-  "thanks", "thank you", "thankyou", "thx", "ty", "cheers", "ok", "okay", "cool",
-]);
-const HELP_PHRASES = [
+/** CAPABILITY questions ("what can you do") — distinct from IDENTITY questions
+ *  ("who are you") below. Both used to be conflated into one HELP_PHRASES list,
+ *  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, /^\?+$/,
-  /^who are you\??$/i, /^what (is|are|r) (this|you)\??$/i, /^how do (i|you) work\??$/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
+  // capability answer a plain "help" gets.
+  /^--help$/i, /^-h$/i, /^man( tmct)?\??$/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
+ *  state, never the code-graph deflection. */
+const IDENTITY_PHRASES = [
+  /^who are you\??$/i, /^what (is|are|r) (this|you)\??$/i,
+  /^what('?s| is) your name\??$/i, /^what exactly are you\??$/i,
+  /^(tell me about|introduce) yourself\??$/i, /^what is this thing\??$/i,
+  /^what am i (talking|speaking|chatting) (to|with)\??$/i,
+  /^you are what\??$/i, /^what thing (are|is) you\??$/i,
+  // "explain [to me|please]* what (you are|this is)" in EITHER word order — a
+  // fluent-but-non-native speaker plausibly types the question-form "what is
+  // this" after "explain" as readily as the statement-form "this is" (SKILL_
+  // CHAT_PLAYTEST §3b's own ESL examples: "explain please what is this" used
+  // to fall through this regex to the grammar wall because only the statement
+  // order was declared).
+  /^explain(?:\s+(?:to me|please))*\s+what\s+(?:is\s+(?:this|it|you)|(?:you are|this is|it is))\??$/i,
+  /^whoami\??$/i,
+  // "hru" ("how are you") — GLUED texting shorthand: no word boundary inside it
+  // for a contraction pass (fuzzyConversationalMatch's SHORTHAND_CONTRACTIONS)
+  // to split on, so it earns its own closed-set entry instead, same as GREET/
+  // THANKS' hand-curated slang. Routed to identity-self (not a fake "doing
+  // great!" performance, nor the generic greeting card) — an honest "what I am"
+  // answer is the closest real thing tmct has to say to "how are you". "wyd"
+  // ("what are you doing") is deliberately NOT given a matching entry: it isn't
+  // an identity question and forcing one would be a fabricated route; it falls
+  // through to the honest generic orientation card same as before.
+  /^hru\??$/i,
+];
+/** "Are you an LLM/AI/bot" — tmct's actual positioning (no LLM, deterministic) is
+ *  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,
+  /^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,
 ];
 /** The structural verbs/nouns that mark a near-miss code question (→ keep the
  *  precise grammar hint, not the friendly nudge). */
@@ -523,16 +639,24 @@ const STRUCT_WORDS = new Set([
   "testing", "defining", "touching", "extending", "inheritance", "coverage", "member", "members",
 ]);
 
+/** Is this raw/normalized query "code-ish" (a dotted/pathed/CamelCase name, "()",
+ *  or a structural keyword)? Shared by isConversational and the fuzzy-typo fallback
+ *  so neither ever grabs a genuine near-miss structural question. */
+function looksCodeish(raw, q) {
+  return /[a-z][A-Z]|[_./]|\(\)/.test(raw) || q.split(/\s+/).some((w) => STRUCT_WORDS.has(w));
+}
+
 /** Does this look like small-talk / an orientation request rather than a
- *  (near-miss) structural question? Greetings & help-phrases always qualify; a
- *  very short input with no code-ish token (dotted/pathed/CamelCase name, "()",
- *  or a structural keyword) does too. */
+ *  (near-miss) structural question? Greetings & help/identity phrases always
+ *  qualify; a very short input with no code-ish token does too. */
 export function isConversational(query) {
   const raw = String(query).trim();
   const q = raw.toLowerCase().replace(/[.!?]+$/, "").trim();
-  if (GREETINGS.has(q)) return true;
-  if (HELP_PHRASES.some((re) => re.test(raw))) return true;
-  const codeish = /[a-z][A-Z]|[_./]|\(\)/.test(raw) || q.split(/\s+/).some((w) => STRUCT_WORDS.has(w));
+  if (GREET.has(q) || THANKS.has(q) || OK_ACK.has(q)) return true;
+  if (CAPABILITY_PHRASES.some((re) => re.test(raw))) return true;
+  if (IDENTITY_PHRASES.some((re) => re.test(raw))) return true;
+  if (AI_IDENTITY_PHRASES.some((re) => re.test(raw))) return true;
+  const codeish = looksCodeish(raw, q);
   return q.split(/\s+/).filter(Boolean).length <= 3 && !codeish;
 }
 
@@ -562,6 +686,11 @@ const T_WHY_EMPTY = "miss-no-previous-answer";
  *  over-promising "ask me about this codebase". */
 const T_GREETING_EMPTY = "conversational-greeting-empty";
 const T_ORIENTATION_EMPTY = "orientation-empty";
+/** IDENTITY answers — self-description and the "no LLM" clarification. Both work
+ *  regardless of graph state (no empty/populated variant): what tmct IS doesn't
+ *  depend on whether a repo is loaded. */
+const T_IDENTITY_SELF = "identity-self";
+const T_IDENTITY_NOT_LLM = "identity-not-an-llm";
 /** 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";
@@ -589,30 +718,139 @@ function tRender(templates, id, slots = {}) {
 // they record as plain turns with empty resolvedIds and never become mgx:asksAbout
 // graph edges (same as /help). Register stays plain and short: this is a code tool.
 
-/** Greetings → a short friendly line + one nudge. A couple carry a tasteful nod. */
+/** Greetings → a short friendly line + one nudge. A couple carry a tasteful nod.
+ *  Deliberately broad across register/dialect (UK/US/AU/NZ, formal, slang, texting
+ *  abbreviation) — a CLOSED curated list, same "never guess" ethos as the rest of
+ *  the file, just a bigger one; see collapseRuns/fuzzyMatchInSet below for the
+ *  typo/elongation multiplier layered on top instead of enumerating every typo. */
 const GREET = new Set([
   "hi", "hello", "hey", "yo", "hiya", "howdy", "sup", "greetings",
   "g'day", "gday", "hey there", "hi there", "hello there",
   "good morning", "good afternoon", "good evening", "morning",
+  // UK/AU/NZ
+  "alright", "you alright", "alright mate", "morning all", "yeah nah",
+  // US
+  "hey y'all", "howdy there", "hiya there",
+  // formal
+  "good day", "salutations", "good to meet you", "pleased to meet you",
+  // slang
+  "yo yo", "ayy", "wassup", "sup fam", "heya", "hiya!",
+  // texting abbreviation
+  "gm", "ge",
 ]);
 /** Acknowledgements → an "any time" style reply. */
 const THANKS = new Set([
   "thanks", "thank you", "thankyou", "thx", "ty", "ta", "cheers", "nice one",
-  "much appreciated", "cool thanks",
+  "much appreciated", "cool thanks", "many thanks", "much obliged", "ta very much",
+  "cheers mate", "cheers for that", "tks", "sweet thanks", "nice",
 ]);
 /** Farewells → a goodbye AND a clean end of session (same path as /exit). */
 const BYE = new Set([
   "bye", "goodbye", "quit", "exit", "see ya", "see you", "cya", "later", "farewell",
+  "peace", "peace out", "im off", "i'm off", "gtg", "gotta go", "catch you later",
+  "good day to you", "farewell then",
 ]);
 /** Elaboration asks → RE-RENDER the last answer verbosely (traversal + matches). */
 const WHY = new Set([
   "why", "how", "how so", "how come", "explain", "say more", "go on",
   "elaborate", "tell me more", "more detail", "expand",
 ]);
+/** Bare acknowledgements — routed identically to THANKS (an "ok"/"cool" after an
+ *  answer reads the same as a thanks, not a new question). Kept separate from
+ *  THANKS/GREET because these aren't greetings or gratitude, just closing a beat. */
+const OK_ACK = new Set([
+  "ok", "okay", "cool", "aight", "fair enough", "got it", "gotcha", "noted",
+  "sounds good", "sure", "cool cool", "right",
+]);
+/** New-user / confused openers — "I don't know what this is" reads as an
+ *  orientation request, not small-talk and not a grammar-wall near-miss; routed
+ *  the same as CAPABILITY_PHRASES (→ orientationAnswer). */
+const ORIENT_OPENERS = new Set([
+  "what", "huh", "confused", "i dont know what this is", "i don't know what this is",
+  "i'm lost", "im lost", "no idea what this does", "just installed this",
+  "just installed you", "i just installed this", "i just installed you",
+  "first time here", "just started", "new to this", "new here",
+]);
 
 // (Greeting/thanks/farewell wording moved to data/templates/responses.jsonl — W1.
 // The expression-specific greeting variants map through T_GREETING_BY_PHRASE above.)
 
+/** Aggressive char-run collapse (2+ identical chars → 1) — used ONLY to build a
+ *  lookup key, never to change what's actually said back. Lets a typed-out
+ *  elongation ("heyyyy", "hellooo", "thanksss") match its canonical phrase for
+ *  free: both the canonical phrase and the elongated input collapse to the same
+ *  key (a legitimate double letter like "hello"'s "ll" collapses identically on
+ *  both sides, so there's no canonical/typed asymmetry to get wrong). */
+const collapseRuns = (s) => s.replace(/(.)\1+/g, "$1");
+
+/** phrase(collapsed) → canonical phrase, built once per closed set. */
+function collapsedIndex(set) {
+  const idx = new Map();
+  for (const phrase of set) if (!idx.has(collapseRuns(phrase))) idx.set(collapseRuns(phrase), phrase);
+  return idx;
+}
+const GREET_COLLAPSED = collapsedIndex(GREET);
+const THANKS_COLLAPSED = collapsedIndex(THANKS);
+const BYE_COLLAPSED = collapsedIndex(BYE);
+
+/** Exact match, else the elongation-collapsed match, else null — the canonical
+ *  phrase either way, so callers never see the raw (possibly elongated) input. */
+function closedOrCollapsed(q, set, idx) {
+  if (set.has(q)) return q;
+  return idx.get(collapseRuns(q)) ?? 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). */
+const CONVERSATIONAL_PHRASES = [
+  ...GREET, ...THANKS, ...BYE,
+  "what can you do", "what do you do", "help", "how do you work",
+  "who are you", "what are you", "what is your name",
+];
+function classifyConversational(phrase) {
+  if (GREET.has(phrase)) return "greet";
+  if (THANKS.has(phrase)) return "thanks";
+  if (BYE.has(phrase)) return "bye";
+  if (phrase === "who are you" || phrase === "what are you" || phrase === "what is your name") return "identity";
+  return "capability";
+}
+/** Standalone-token texting shorthand for this lane ONLY: "r"→"are", "u"→"you",
+ *  word-boundary matched so a substring inside a real word ("your", "sure",
+ *  "minute") is never touched. This is the SAME normalization class as
+ *  ask-vocab.mjs's CONTRACTIONS table (word-boundary, case-insensitive,
+ *  longest-key-first — see interpret/normalize.mjs's tableRe), but deliberately
+ *  NOT routed through that shared table/normalizeQuery: those feed ask.mjs's
+ *  code-graph grammar pipeline, where a bare "u"/"r" plausibly collides with a
+ *  real dotted identifier ("u.mjs" as a module name) — and conversationalTurn()
+ *  never calls normalizeQuery at all, so extending the shared table wouldn't
+ *  even reach this lane. Scoped locally to the fuzzy-conversational tier
+ *  instead, applied BEFORE the candidate lookup below, so "waht r u"/"wat r u"
+ *  first become "waht are you"/"wat are you" — within the existing bounded
+ *  edit-distance of "who are you"/"what are you" — and resolve exactly the way
+ *  a plain-English typo does. GLUED shorthand ("hru", "wyd") has no word
+ *  boundary to split on and is NOT reached by this pass; see IDENTITY_PHRASES
+ *  for "hru"'s separate closed-set entry. */
+const SHORTHAND_CONTRACTIONS = { r: "are", u: "you" };
+const SHORTHAND_CONTRACTION_RE = /\b(r|u)\b/gi;
+function expandShorthandContractions(text) {
+  return text.replace(SHORTHAND_CONTRACTION_RE, (m) => SHORTHAND_CONTRACTIONS[m.toLowerCase()]);
+}
+
+/** UNIQUE within-bound fuzzy match of the whole trimmed line against
+ *  CONVERSATIONAL_PHRASES — the "helo"/"thnx"/"byee" tier, plus (after shorthand
+ *  contraction expansion above) "waht r u"/"wat r u"-style texting shorthand.
+ *  Restricted to short (≤4-word), non-code-ish inputs (looksCodeish, shared with
+ *  isConversational) so a genuine near-miss structural question is never grabbed;
+ *  a distance tie is refused, never guessed (same discipline as fuzzyVocabWord). */
+function fuzzyConversationalMatch(raw) {
+  const expanded = expandShorthandContractions(raw);
+  const q = collapseRuns(expanded.toLowerCase().replace(/[.!?]+$/, "").trim());
+  const words = q.split(/\s+/).filter(Boolean);
+  if (!words.length || words.length > 4 || looksCodeish(raw, q)) return null;
+  return fuzzyMatchInSet(q, CONVERSATIONAL_PHRASES, Math.min(2, fuzzyBound(q)));
+}
+
 /** Re-render the last answer in verbose form: the previous query + its full answer
  *  plus the ask envelope's traversal receipt and the matched entities (the detail a
  *  terse render trims). `empty:true` when there's no previous answer to expand. */
@@ -643,7 +881,7 @@ export function renderVerbose(last) {
 function conversationalTurn(line, ctx) {
   const raw = String(line);
   const q = raw.toLowerCase().replace(/[.!?]+$/, "").replace(/\s+/g, " ").trim();
-  const t = (id) => tRender(ctx.templates, id) ?? TEMPLATES_UNAVAILABLE;
+  const t = (id, slots = {}) => tRender(ctx.templates, id, slots) ?? TEMPLATES_UNAVAILABLE;
   const mk = (answer, { end = false, miss = false, via = "template" } = {}) => {
     const ts = new Date().toISOString();
     return {
@@ -675,27 +913,61 @@ function conversationalTurn(line, ctx) {
     note(ctx.trace, `result: re-rendering the previous answer to "${ctx.last?.query ?? "?"}" verbosely`);
     return mk(v.text, { via: "conversational" });
   }
-  if (GREET.has(q)) {
-    note(ctx.trace, "goal: casual/social — greeting, no graph intent");
-    note(ctx.trace, "lane: conversational — greeting (GREET closed set)");
-    // #3 empty/degenerate-graph greeting: a plain "hi"/"hello" over a graph with 0
-    // modules orients toward --repo/tmct init instead of over-promising "ask me
-    // about this codebase". Phrase-specific variants (good morning, hello there)
-    // keep their wording; only the default greeting swaps.
-    const id = (!T_GREETING_BY_PHRASE[q] && noCodeGraph(ctx.graph)) ? T_GREETING_EMPTY : (T_GREETING_BY_PHRASE[q] || T_GREETING);
-    note(ctx.trace, `pattern: template "${id}" (data/templates/responses.jsonl)`);
-    return mk(t(id));
-  }
-  if (THANKS.has(q)) {
-    note(ctx.trace, "goal: casual/social — acknowledgement, no graph intent");
-    note(ctx.trace, "lane: conversational — thanks/acknowledgement (THANKS closed set)");
-    note(ctx.trace, `pattern: template "${T_THANKS}" (data/templates/responses.jsonl)`);
-    return mk(t(T_THANKS));
-  }
-  if (q === "help" || q === "?" || HELP_PHRASES.some((re) => re.test(raw))) {
+  {
+    const greetHit = closedOrCollapsed(q, GREET, GREET_COLLAPSED);
+    if (greetHit) {
+      note(ctx.trace, "goal: casual/social — greeting, no graph intent");
+      note(ctx.trace, `lane: conversational — greeting (GREET closed set${greetHit === q ? "" : ", elongation-collapsed"})`);
+      // #3 empty/degenerate-graph greeting: a plain "hi"/"hello" over a graph with 0
+      // modules leads with the (now provably-correct) vocabulary hint instead of
+      // over-promising "ask me about this codebase". Phrase-specific variants (good
+      // morning, hello there) keep their wording; only the default greeting swaps.
+      const id = (!T_GREETING_BY_PHRASE[greetHit] && noCodeGraph(ctx.graph)) ? T_GREETING_EMPTY : (T_GREETING_BY_PHRASE[greetHit] || T_GREETING);
+      note(ctx.trace, `pattern: template "${id}" (data/templates/responses.jsonl)`);
+      return mk(t(id, { vocabHint: ctx.vocabHint }));
+    }
+  }
+  {
+    const thanksHit = closedOrCollapsed(q, THANKS, THANKS_COLLAPSED) || (OK_ACK.has(q) ? q : null);
+    if (thanksHit) {
+      note(ctx.trace, "goal: casual/social — acknowledgement, no graph intent");
+      note(ctx.trace, `lane: conversational — thanks/acknowledgement (${OK_ACK.has(q) ? "OK_ACK" : "THANKS"} closed set${thanksHit === q ? "" : ", elongation-collapsed"})`);
+      note(ctx.trace, `pattern: template "${T_THANKS}" (data/templates/responses.jsonl)`);
+      return mk(t(T_THANKS));
+    }
+  }
+  if (AI_IDENTITY_PHRASES.some((re) => re.test(raw))) {
+    note(ctx.trace, "goal: identity — is tmct an AI/LLM (a very likely first question)");
+    note(ctx.trace, "lane: conversational — identity/AI (AI_IDENTITY_PHRASES closed set)");
+    return mk(t(T_IDENTITY_NOT_LLM));
+  }
+  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)");
+    return mk(t(T_IDENTITY_SELF));
+  }
+  if (q === "help" || q === "?" || CAPABILITY_PHRASES.some((re) => re.test(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 (HELP_PHRASES / bare help / ?)");
-    return mk(orientationAnswer(ctx.templates, ctx.graph));
+    note(ctx.trace, "lane: conversational — help/orientation (CAPABILITY_PHRASES/ORIENT_OPENERS / bare help / ?)");
+    return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint));
+  }
+  // Fuzzy-typo fallback (A4): every exact/collapsed closed-set lookup above missed —
+  // try a bounded edit-distance match against the flattened conversational phrase
+  // pool ("helo", "thnx", "wat r u", "byee"), restricted to short non-code-ish
+  // input so a genuine near-miss structural question is never grabbed.
+  {
+    const fuzzyHit = fuzzyConversationalMatch(raw);
+    if (fuzzyHit) {
+      const bucket = classifyConversational(fuzzyHit);
+      note(ctx.trace, `goal: casual/social or orientation — fuzzy-typo match "${raw}" → "${fuzzyHit}"`);
+      note(ctx.trace, `lane: conversational — fuzzy typo tolerance (${bucket})`);
+      if (bucket === "bye") return mk(t(T_FAREWELL), { end: true });
+      if (bucket === "thanks") return mk(t(T_THANKS));
+      if (bucket === "identity") return mk(t(T_IDENTITY_SELF));
+      if (bucket === "capability") return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint));
+      const id = (!T_GREETING_BY_PHRASE[fuzzyHit] && noCodeGraph(ctx.graph)) ? T_GREETING_EMPTY : (T_GREETING_BY_PHRASE[fuzzyHit] || T_GREETING);
+      return mk(t(id, { vocabHint: ctx.vocabHint }));
+    }
   }
   return null;
 }
@@ -754,22 +1026,30 @@ function orientationExamples(graph) {
   return { example1, example2 };
 }
 
-/** The orientation surface, module-aware: the empty variant (→ --repo/tmct init +
- *  seeded vocabulary) when there's no code graph, the standard one (with live
- *  {example1}/{example2} query examples from the loaded graph) otherwise. */
-function orientationAnswer(templates, graph) {
-  if (noCodeGraph(graph)) return tRender(templates, T_ORIENTATION_EMPTY) ?? TEMPLATES_UNAVAILABLE;
+/** The orientation surface, module-aware: the empty variant (→ the provably-correct
+ *  vocabulary hint + --repo/tmct init) when there's no code graph, the standard one
+ *  (with live {example1}/{example2} query examples from the loaded graph) otherwise. */
+function orientationAnswer(templates, graph, vocabHint) {
+  if (noCodeGraph(graph)) return tRender(templates, T_ORIENTATION_EMPTY, { vocabHint }) ?? TEMPLATES_UNAVAILABLE;
   return tRender(templates, T_ORIENTATION, orientationExamples(graph)) ?? TEMPLATES_UNAVAILABLE;
 }
 
+/** A minimal, still identity-led fallback for orientationText's empty-graph branch
+ *  — used ONLY if the template library itself failed to load (tRender returned
+ *  null), matching the file's "never crash, always degrade to one honest line"
+ *  ethos. Kept short and hand-written so it never drifts silently. */
+const ORIENTATION_EMPTY_FALLBACK = "I'm tmct — a deterministic, offline chat assistant (no LLM). "
+  + "For code structure (imports, calls, definitions) point me at a repo with `--repo <path>`, "
+  + "or try the shipped example `npm run example:mini`. tmct reads graphs; it doesn't index code itself. /help for commands.";
+
 /** A dynamic orientation string for the meta/self lane: a /stats-style overview
- *  when a code graph is loaded, else the honest empty-graph orientation. */
-function orientationText(graph) {
+ *  when a code graph is loaded, else the honest empty-graph orientation — rendered
+ *  through the SAME template (T_ORIENTATION_EMPTY) conversationalTurn's orientation
+ *  branch uses, so there is exactly one copy of that wording to keep in sync, not
+ *  two hand-duplicated strings. */
+function orientationText(graph, templates, vocabHint) {
   if (noCodeGraph(graph)) {
-    return "There's no code graph loaded here, so I can't answer structure questions (imports, calls, definitions) yet. "
-      + "For those I need a `.tmct/graph.json` produced by a graph producer — point me at one with `--repo <path>`, "
-      + "or try the shipped example `npm run example:mini`. tmct reads graphs; it doesn't index code itself. "
-      + 'For general vocabulary, `tmct init` seeds concepts — try "what is a cache". /help for commands.';
+    return tRender(templates, T_ORIENTATION_EMPTY, { vocabHint }) ?? ORIENTATION_EMPTY_FALLBACK;
   }
   const by = (cls) => (graph.individuals || []).filter((i) => (i.class || "") === cls).length;
   const parts = [];
@@ -940,10 +1220,22 @@ function assertCandidates(payload) {
   if (!/^(?:every|each|all|a|an)\b/i.test(p)) out.push(`every ${p}`);
   return [...new Set(out)];
 }
-/** The "every X is a Y" rewrite of a declarative, for the "did you mean …" hint. */
+/** The "every X is a Y" rewrite of a declarative, for the "did you mean …" hint.
+ *  BUG 2 fix (2026-07-08): the article was hardcoded to "a" regardless of Y's
+ *  vowel sound ("every monkey is a animal" — ungrammatical for a vowel-initial
+ *  Y), which made the suggestion silently WRONG for exactly the cases where a
+ *  correction is most useful. Real a/an agreement now reuses finish.mjs's own
+ *  beginsWithVowelSound + the SAME grammar-rules.toml "article" rule
+ *  (spelling-vowel/consonant exceptions included) rather than reimplementing
+ *  vowel-sound detection a second time. */
 function teachSuggestion(payload) {
   const m = String(payload).match(/^(?:every |each |all |a |an )?([\w-]+) (?:is|are) (?:a |an )?([\w-]+)$/i);
-  return m ? `every ${m[1].toLowerCase()} is a ${m[2].toLowerCase()}` : null;
+  if (!m) return null;
+  const subject = m[1].toLowerCase();
+  const object = m[2].toLowerCase();
+  const articleRule = grammarRules().find((r) => r.kind === "article");
+  const article = articleRule && beginsWithVowelSound(object, articleRule) ? "an" : "a";
+  return `every ${subject} is ${article} ${object}`;
 }
 
 async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
@@ -988,10 +1280,52 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
       }
     }
   }
+  // BUG 2 fix (2026-07-08): compare the CORRECTED suggestion against a
+  // normalized (trimmed, whitespace-collapsed, lowercased) form of what the
+  // user actually typed, not the raw payload — so trivial formatting
+  // differences never manufacture a spurious "did you mean". With
+  // teachSuggestion's article now grammatically correct (above), this
+  // equality guard's original intent is restored rather than replaced: it
+  // suppresses the hint exactly when X and Y themselves are already spelled
+  // in the canonical "every X is a Y" shape (nothing useful to add), and
+  // shows it whenever the corrected form differs — including the wrong-
+  // article case ("every monkey is a animal") that used to be silently
+  // suppressed because the OLD teachSuggestion's own hardcoded "a" matched
+  // the user's mistake byte-for-byte.
+  const normalizedPayload = String(payload).trim().toLowerCase().replace(/\s+/g, " ");
   const suggestion = teachSuggestion(payload);
-  const did = suggestion && suggestion !== payload.toLowerCase() ? ` Did you mean: "${suggestion}"?` : "";
+  const did = suggestion && suggestion !== normalizedPayload ? ` Did you mean: "${suggestion}"?` : "";
+  // Honest miss reason (2026-07-08, "separately, not a bug" clarification): when
+  // the payload structurally fits the ACE fragment but names word(s) outside
+  // tmct's closed 180-word lexicon (lexicon-core.json), parseAce already
+  // reports exactly which tokens are unrecognized as `residue` — assertTurn's
+  // loop above discards it on a miss. Re-derive it here (same lexicon, same
+  // candidate sentences) so the miss message can NAME the word(s), rather than
+  // leaving the user to guess whether the problem was grammar shape or
+  // vocabulary. A payload that doesn't fit the fragment AT ALL (parseAce
+  // returns null, no residue) gets the plain generic message — genuinely a
+  // shape mismatch, not an unrecognized-word one. This does NOT widen the
+  // lexicon itself: "redis"/"monkey"/"animal" still fail to store; the
+  // message now says why.
+  let unknown = [];
+  if (memoryDir) {
+    try {
+      const { parseAce } = await import("./grammar/ace.mjs");
+      let lex = lexicon;
+      if (!lex) { const { loadLexicon } = await import("./grammar/lexicon.mjs"); lex = loadLexicon(); }
+      for (const cand of assertCandidates(payload)) {
+        const parse = parseAce(cand, lex);
+        if (parse?.residue?.length) { unknown = [...new Set(parse.residue.map((w) => String(w).toLowerCase()))]; break; }
+      }
+    } catch { /* lexicon unavailable — fall through to the generic message */ }
+  }
+  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."
+    : "";
   return {
-    text: 'I couldn\'t store that — I remember facts in the shape "every X is a Y", where X and Y are '
+    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.`,
     via: "teach-miss", miss: true,
   };
@@ -1008,13 +1342,23 @@ const WHAT_KNOW_RE = /^what\s+(?:do\s+you|d'?you)\s+know(?:\s+so\s+far)?$/;
 // 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))$/;
 
-/** A SHORT memory summary (never a fact dump) for the bare "what do you know". */
+/** 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
+ *  vocabulary seeding either hasn't run or produced nothing, so the hook makes NO
+ *  term-specific promise (an unconditionally-true pointer: the teach lane and
+ *  `tmct init` both work with zero preconditions), rather than suggesting a
+ *  vocabulary example that would be guaranteed to miss right after being offered.
+ *  The no-code-graph branch's teach example is a CONCRETE pair from the closed
+ *  ACE lexicon (playtest: an abstract "every X is a Y" invites a curious user to
+ *  substitute intuitive-but-unknown words — "every cache is a thing" — which the
+ *  closed lexicon then rejects; "every bug is an issue" is confirmed to parse and
+ *  store, see test/chatflow-tier0.test.mjs). */
 async function memorySummary(memoryDir, graph) {
   const rows = memoryDir ? await memoryFacts(memoryDir) : [];
   if (!rows.length) {
     const hook = moduleCountOf(graph) > 0
       ? 'ask about this codebase\'s structure (imports, calls, definitions), or teach me with "every X is a Y"'
-      : 'teach me with "every X is a Y", or try general vocabulary like "what is a cache"';
+      : 'run `tmct init` to seed a starter vocabulary, or teach me directly, e.g. "every bug is an issue"';
     return `I haven't been told any facts yet — ${hook}. /memory to inspect, /help for commands.`;
   }
   const preds = new Set(rows.map((f) => f.predicate).filter(Boolean));
@@ -1052,7 +1396,7 @@ async function moduleOrientLane(query, { graph }) {
   return { text: moduleOverviewText(graph, ind), via: "meta" };
 }
 
-async function metaLane(query, { graph, memoryDir, last = null }) {
+async function metaLane(query, { graph, memoryDir, last = null, templates = null, vocabHint = null }) {
   const q = String(query).trim().toLowerCase().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
   if (WHAT_KNOW_RE.test(q) || q === "what have you learned" || q === "what have you learnt") {
     return { text: await memorySummary(memoryDir, graph), via: "meta" };
@@ -1065,7 +1409,7 @@ async function metaLane(query, { graph, memoryDir, last = null }) {
     // orientationText(graph) verbatim on every repeat, never collapsing). Mirrors
     // ORIENTATION_REPEAT_ONELINER's identity-check pattern exactly, with its own
     // distinct oneliner text (self-limiting for the same reason).
-    const text = orientationText(graph);
+    const text = orientationText(graph, templates, vocabHint);
     return { text: last?.answer === text ? META_ORIENT_REPEAT_ONELINER : text, via: "meta" };
   }
   // Bug E: an arbitrary "what does <term> do" that META_ORIENT_RE's closed noun
@@ -1137,6 +1481,56 @@ const IMPERATIVE_NUDGE_RE =
   /^(?:please\s+)?(?:(?:can|could|would|will)\s+you\s+(?:please\s+)?)?(?:make|write|create|add|generate|implement|fix|refactor)\b(?=.*\b(?:tests?|code|functions?|methods?|modules?|class(?:es)?|files?|it)\b)/i;
 const WHY_UNTESTED_RE = /^why\s+(?:is|are)(?:n't|\s+not)?\s+(.+?)\s+(?:untested|not\s+tested|uncovered)$/i;
 
+// #5(g) OUT-OF-DOMAIN PERSONAL-ASSISTANT NUDGE (BUG 3 fix, 2026-07-08): "what
+// time is it" / "what's the weather" / "what day is it" — obviously not an
+// attempted code-graph query at all (no structural noun/verb), but 4+ words
+// with no dotted/camelCase/"()" token, so it slips past BOTH looksCodeish and
+// isConversational's ≤3-word catch-all, straight to the raw grammar wall
+// ("couldn't parse this as a graph question. Try: ...") — a dead-end per
+// SKILL_CHAT_PLAYTEST.md §0 ("every turn either answers, or gives a guiding
+// nudge... a turn that does neither is a dead-end"). A small closed set, same
+// discipline as RISK_NUDGE_RE/OPINION_NUDGE_RE above: this is a genuine
+// capability ceiling (tmct has no clock/calendar/weather capability) — the
+// fix is an honest decline pointing back at what tmct actually does, never a
+// fabricated time/date/weather answer.
+// "what(?:'s|s|\s+is)" also accepts the bare "whats" spelling — the same
+// informal contraction ask-vocab.mjs's own CONTRACTIONS table maps to "what
+// is" for the graph-query path; nudgeAnswer sees the raw (not contraction-
+// normalized) query text, so it earns its own tolerance here too.
+const PERSONAL_ASSISTANT_NUDGE_RE = new RegExp(
+  "^(?:"
+  + "what\\s+time\\s+is\\s+it(?:\\s+(?:now|right\\s+now))?"
+  + "|what(?:'s|s|\\s+is)\\s+the\\s+time(?:\\s+(?:now|right\\s+now))?"
+  + "|what\\s+day\\s+is\\s+it(?:\\s+today)?"
+  + "|what(?:'s|s|\\s+is)\\s+(?:the\\s+)?(?:day|date)(?:\\s+today)?"
+  + "|what(?:'s|s|\\s+is)\\s+today'?s\\s+date"
+  + "|what(?:'s|s|\\s+is)\\s+the\\s+weather(?:\\s+like)?(?:\\s+(?:today|outside))?"
+  + "|how'?s\\s+the\\s+weather(?:\\s+like)?(?:\\s+(?:today|outside))?"
+  + ")\\??$",
+  "i",
+);
+
+/** STACCATO NEGATION ("not X", "not X then", "except X") — SKILL_CHAT_PLAYTEST
+ *  Tier-2, 5th pass: a rapid-fire rejection of a specific item, with no verb at
+ *  all — the bare-connective sibling of STACCATO_PRONOUN_RE/STACCATO_SWAP_RE
+ *  (below), but with no positive alternative named. Two flavors, BOTH
+ *  genuinely unanswerable as a real graph query (never fabricated):
+ *   - a BARE pronoun rejection ("not that one", "not those", "not it") names
+ *     no alternative at all — what the user DOES want instead is known only
+ *     to them, not derivable from the graph.
+ *   - a NAMED rejection ("not app/lib/b.mjs", "not Widget then") names a real
+ *     candidate to EXCLUDE from a just-given list, but excluding a member
+ *     from a prior result set is a capability the engine genuinely doesn't
+ *     have yet (verified live: even the fully-spelled "which of those is not
+ *     X" doesn't compile — parsePredicateFilter has no negation branch).
+ *  Before this, both fell to the generic orientation card (a short,
+ *  non-codeish turn trips isConversational's ≤3-word catch-all) or the raw
+ *  grammar wall (a codeish one, e.g. a path) — neither names what actually
+ *  went wrong. This is an honest, GUIDING nudge (§0), never a fabricated
+ *  filtered answer and never a bare wall. */
+const STACCATO_NEGATION_RE = /^(?:and\s+)?(?:not|except(?:\s+for)?)\s+(.+?)(?:\s+then|\s+though)?[?.!]*$/i;
+const NEGATION_PRONOUN_RE = /^(?:it|that|this|those|them)(?:\s+ones?)?$/i;
+
 /** The <name> a nudge shows: the focus label when the query leans on a pronoun (or
  *  gave us nothing better), else the captured subject; "<name>" as the placeholder. */
 function nudgeName(captured, focus) {
@@ -1151,6 +1545,10 @@ function nudgeName(captured, focus) {
  *  short-miss rewrite). */
 function nudgeAnswer(query, focus) {
   const q = String(query).trim().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
+  if (PERSONAL_ASSISTANT_NUDGE_RE.test(q)) {
+    return "I don't have access to that — I'm a deterministic code/vocabulary assistant, not a general assistant. "
+      + 'Ask me about code structure ("which modules import <name>") or try "what is a cache".';
+  }
   if (OPINION_NUDGE_RE.test(q)) {
     const name = focus?.label || "<name>";
     return "I don't hold opinions — I read structure, not quality. I can show what an opinion would rest on: "
@@ -1172,6 +1570,16 @@ function nudgeAnswer(query, focus) {
     return "I don't write code — I read a graph of it. "
       + `/tests ${name} shows what covers it; "untested modules" shows the gaps.`;
   }
+  const neg = q.match(STACCATO_NEGATION_RE);
+  if (neg) {
+    const term = neg[1].trim();
+    if (NEGATION_PRONOUN_RE.test(term)) {
+      const name = focus?.label || "Widget";
+      return `not sure what you'd like instead of ${focus?.label || "that"} — name it directly, e.g. "what calls ${name}".`;
+    }
+    return "I can't filter a previous list by exclusion yet — ask the positive shape directly "
+      + `(e.g. "which modules import <name>"), or ask about ${term} on its own.`;
+  }
   return null;
 }
 
@@ -1514,6 +1922,46 @@ const FACT_PREDICATE_PHRASES = {
 };
 const factPhrase = (f) => `${f.subject} ${FACT_PREDICATE_PHRASES[f.predicate] || f.predicate} ${f.object}`;
 
+// ---- BUG 1 fix (2026-07-08): "what is a tree used for" filters to JUST the
+// UsedFor facts, instead of grammar.mjs's meta-whatis template's lazy tail
+// swallowing "tree used for" whole as one literal term (a guaranteed
+// vocabulary-lookup miss — "tree used for" names no class/predicate). Reuses
+// FACT_PREDICATE_PHRASES itself as the marker vocabulary (no second table):
+// every phrase that reads as "<copula> <marker>" (e.g. "is used for", "is
+// part of") derives a trailing marker ("used for", "part of") a "what is a
+// <subject> <marker>" question can end on, since the leading "is" is already
+// consumed by the template's own "what is" anchor. Phrases with no leading
+// is/are copula ("can", "causes", "requires", "has", …) don't fit that
+// question shape at all and are correctly excluded automatically — this is a
+// DERIVATION, not a curated subset. The single-letter "a" (from rdf:type's
+// bare "is a") is excluded explicitly: too short to anchor on without a real
+// risk of eating a genuine multi-word subject ending in "a".
+const TRAILING_PREDICATE_MARKERS = Object.entries(FACT_PREDICATE_PHRASES)
+  .map(([predicate, phrase]) => {
+    const m = /^(?:is|are)\s+(.+)$/i.exec(phrase);
+    return m ? { predicate, marker: m[1].trim().toLowerCase() } : null;
+  })
+  .filter((e) => e && e.marker.length > 1)
+  .sort((a, b) => b.marker.length - a.marker.length); // longest marker first
+
+/** Split a meta-shaped term into {subject, predicate}: "tree used for" ->
+ *  {subject:"tree", predicate:"mgx:usedFor"} when the term ends in a known
+ *  TRAILING_PREDICATE_MARKERS marker with a non-empty subject ahead of it;
+ *  otherwise {subject: term, predicate: null} (the term stands as-is — the
+ *  ordinary undifferentiated "what is a X" behavior). Pure, no I/O. */
+function splitMetaPredicate(term) {
+  const t = String(term || "").trim();
+  const lower = t.toLowerCase();
+  for (const { marker, predicate } of TRAILING_PREDICATE_MARKERS) {
+    if (lower === marker) continue; // no subject left to the left of the marker
+    if (lower.endsWith(` ${marker}`)) {
+      const subject = t.slice(0, t.length - marker.length).trim();
+      if (subject) return { subject, predicate };
+    }
+  }
+  return { subject: t, predicate: null };
+}
+
 /** One rendered fact line. An OPERATOR-asserted fact keeps the true first-person
  *  provenance ("you told me: …"). A CORPUS fact is presented as clean DATA with its
  *  source cited — NEVER "i learned: …", which over-claims and anthropomorphises
@@ -1697,9 +2145,29 @@ async function factAnswer(memoryDir, query, envelope, miss) {
     if (m) metaTerm = m[1];
   }
   if (metaTerm) {
-    const variants = factTermVariants(normFactTerm, metaTerm);
-    const hits = (await memoryFacts(memoryDir)).filter((f) => variants.has(f.subject));
-    if (!hits.length) return null;
+    // BUG 1 fix: "what is a tree used for" parses (grammar.mjs T5) to the
+    // WHOLE tail "tree used for" as one literal term — split off a trailing
+    // FACT_PREDICATE_PHRASES marker (if any) so the real subject ("tree") is
+    // matched against fact subjects, and — the actual bug — the result is
+    // FILTERED to just that one predicate (mgx:usedFor) instead of every
+    // relation about the subject undifferentiated.
+    const { subject, predicate } = splitMetaPredicate(metaTerm);
+    const variants = factTermVariants(normFactTerm, subject);
+    const subjectHits = (await memoryFacts(memoryDir)).filter((f) => variants.has(f.subject));
+    const hits = predicate ? subjectHits.filter((f) => f.predicate === predicate) : subjectHits;
+    if (!hits.length) {
+      // The subject itself is known, but not under this specific relation —
+      // an honest, specific "no" rather than falling through to the generic
+      // "isn't a term in this graph's own vocabulary" wall (which would be
+      // actively misleading here: the subject IS a known term).
+      if (predicate && subjectHits.length) {
+        return {
+          text: `I don't have any "${FACT_PREDICATE_PHRASES[predicate]}" facts about ${subject}.`,
+          replace: miss,
+        };
+      }
+      return null;
+    }
     const lines = hits.map(renderFactLine);
     const shown = lines.slice(0, FACT_ANSWER_CAP);
     const rest = lines.slice(FACT_ANSWER_CAP);
@@ -2104,9 +2572,28 @@ async function recallSummary(memoryDir) {
 /** "[and/so/…] what about X" — a discourse continuation that re-asks the previous
  *  turn's question with X swapped in. */
 const WHAT_ABOUT_RE = /^(?:(?:and|so|but|ok|okay|now|then)\s+)*what about\s+(.+?)[?.!\s]*$/i;
-/** A code-ish name token in a prior query (a path/dotted name, or a CamelCase/
- *  Capitalized symbol) — the subject "what about X" replaces. */
-const NAME_TOKEN_RE = /\b[\w-]+(?:[/.][\w-]+)+\b|\b[A-Z][A-Za-z0-9_]*\b/;
+/** A code-ish name token in a prior query (a path/dotted name, a Capitalized
+ *  symbol, or a lowerCamelCase identifier like `saveStore`/`createTask`) — the
+ *  subject "what about X" replaces. The lowerCamelCase alternative (0.9.13
+ *  Tier-1 playtest) closes a real drill-down gap: a chain focused on a FUNCTION
+ *  ("what does saveStore call") has no Capitalized/path token at all, so "what
+ *  about X" after it used to fall straight through to the honest-miss instead
+ *  of continuing the shape — a mid-word capital never occurs in plain English,
+ *  so this is a safe, unambiguous code-identifier signal. */
+const NAME_TOKEN_RE = /\b[\w-]+(?:[/.][\w-]+)+\b|\b[A-Z][A-Za-z0-9_]*\b|\b[a-z][a-z0-9]*[A-Z][A-Za-z0-9]*\b/;
+
+/** STACCATO SWAP CONTINUATION (0.9.15 Tier-2 playtest, 4th pass): the bare-
+ *  connective sibling of WHAT_ABOUT_RE — "and Widget?", "also app/lib/b.mjs" —
+ *  with no "about" at all. A rapid-fire drill-down chain naturally shortens
+ *  to this once the shape is established ("what calls app/lib/a.mjs" -> "and
+ *  Widget?" meaning "and what calls Widget?"). Unlike WHAT_ABOUT_RE's
+ *  explicit question framing, a bare connective is otherwise too ambiguous
+ *  with ordinary discourse ("and then?", "so what") to safely reinterpret as
+ *  a subject swap — discourseRewrite below only trusts this shape when the
+ *  captured word is ITSELF unambiguously code-ish (NAME_TOKEN_RE): a path, a
+ *  Capitalized symbol, or lowerCamelCase. A plain word ("and stuff?") never
+ *  matches and falls through unchanged. */
+const STACCATO_SWAP_RE = /^(?:and|also|so|then|now)\s+(.+?)[?.!\s]*$/i;
 
 /** DISCOURSE CONTINUATION (CHATBENCH_006 lever 2): "what about X" carries the PRIOR
  *  turn's question shape across the turn boundary — re-asking it with X in place of
@@ -2115,10 +2602,18 @@ const NAME_TOKEN_RE = /\b[\w-]+(?:[/.][\w-]+)+\b|\b[A-Z][A-Za-z0-9_]*\b/;
  *  no prior query or no name token to swap (→ the ordinary honest miss stands). */
 function discourseRewrite(query, last) {
   const m = String(query).match(WHAT_ABOUT_RE);
-  if (!m || !last?.query) return null;
+  let newSubj;
+  if (m) {
+    newSubj = m[1].trim();
+  } else {
+    const sm = String(query).match(STACCATO_SWAP_RE);
+    const cand = sm?.[1]?.trim();
+    if (!cand || !NAME_TOKEN_RE.test(cand)) return null;
+    newSubj = cand;
+  }
+  if (!last?.query) return null;
   const prevQ = String(last.query);
   if (!NAME_TOKEN_RE.test(prevQ)) return null;
-  const newSubj = m[1].trim();
   return prevQ.replace(NAME_TOKEN_RE, () => newSubj);
 }
 
@@ -2236,11 +2731,61 @@ async function curatedDefinitionAnswer(query, envelope, { memoryDir, lexicon })
  *  "imports"), which the RELATION force must never preempt (frozen case
  *  am-meta-imports). Gated downstream by CONCEPT_CLASS / RELATION_TERM, so a real
  *  entity name declines here. */
+// "tel" -> "tell" (0.9.14 Tier-2 playtest): the dropped-letter typo of THIS
+// lane's own anchor word — "tel me about calls" used to miss the "^tell me
+// about …" regex entirely and fall through to a bogus "no module matching
+// 'tel me'" search. "tell" is not itself part of ask.mjs's code-graph grammar
+// (VERB_TO_KIND/ENTITY_TO_TYPE/anchor words), so it can't live in the shared
+// ask-vocab.mjs MISSPELLINGS table (test/ask-vocab.test.mjs enforces every
+// correction value is grammar-owned) — same reasoning as chat.mjs's own
+// 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;
+/** "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
+ *  the isConversational-catch-all exemption (below, deduceGoalFromParsed's
+ *  neighbourhood) can test the SAME shape. */
+const EXPLAIN_TOUCH_RE = /^(?:please\s+|kindly\s+)*explain\s+(?:to\s+me\s+)?(?:an?\s+|the\s+)?(.+?)(?:\s+(?:to\s+me|please))?[?.!\s]*$/i;
 function vagueTouchTermOf(query) {
-  const q = String(query).trim();
-  const m = q.match(/^tell me about\s+(?:an?\s+)?(.+?)[?.!\s]*$/i)
-    || q.match(/^(?:(?:and|so|but|ok|okay|now|then)\s+)*what about\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i);
-  return m ? m[1].trim() : null;
+  // typo-correct the ANCHOR words only ("waht about calls" -> "what about
+  // calls") — this shape has no ask()-grammar envelope to lean on for typo
+  // tolerance (unlike metaTermOf's "what is a X", which mostly gets it for
+  // free off envelope.parsed once ask() itself has normalized). Then peel the
+  // SAME closed greeting/thanks/modal-wrapper preambles ask()'s own grammar
+  // already peels (0.9.14 Tier-2 playtest §3b spot-check: "cheers, what about
+  // imports then" and "could you kindly tell me about the calls" both used to
+  // fall through to a bogus object search) — applyPreambleFrames alone, NOT
+  // the full normalizeQuery pipeline, which also runs subordination/
+  // conditional rewrites that turn "tell me about X" into "about X" (its own
+  // bridge frame), breaking this very regex.
+  let q = correctMisspellings(String(query).trim());
+  q = q.replace(VAGUE_TOUCH_TEL_RE, "tell");
+  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)
+    // "explain X" (0.9.14 Tier-2 playtest, second pass, §3b formal/ESL angle)
+    // — a bare "explain <term>" is at least as natural a vague touch as "tell
+    // me about X", but had no recognized shape at all: normalize.mjs's own
+    // EXPLAIN_WRAPPER_RE only unwraps a WH-QUESTION remainder ("explain
+    // please where is it defined" -> a real structural question), so a bare
+    // noun remainder like "cochange" was never its territory. A leading
+    // "please"/"kindly" also broke the STRUCTURAL pipeline's own
+    // EXPLAIN_WRAPPER_RE (anchored to start with "explain" literally),
+    // sending the whole turn to the wrong lane.
+    || q.match(EXPLAIN_TOUCH_RE);
+  if (!m) return null;
+  // A trailing meta-noun naming WHAT KIND of thing the touched word already is
+  // (0.9.14 Tier-2 playtest, second pass): "tell me about the cochange
+  // relation" / "what about the calls relationship" / "what about the imports
+  // edges" used to capture the WHOLE tail ("cochange relation") as the term —
+  // RELATION_TERM's closed dict has no multi-word entries, so the relation
+  // force declined and the query fell through to the grammar wall. Stripped
+  // for both callers (conceptTermOf's noun touch and relationTermOf's edge
+  // touch): a noun concept is never phrased with this tail ("tell me about
+  // the Class relation" isn't natural), so it's safe either way.
+  const term = m[1].trim().replace(/\s+(?:relations?|relationships?|edges?)$/i, "").trim();
+  return term || null;
 }
 
 function conceptTermOf(query, envelope) {
@@ -2257,14 +2802,37 @@ function conceptTermOf(query, envelope) {
 function relationTermOf(query, envelope) {
   const base = vagueTouchTermOf(query);
   if (base) return base;
-  const q = String(query).trim().toLowerCase().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
+  // same typo-correction as vagueTouchTermOf above ("waht calls are there" ->
+  // "what calls are there") — these openers are chat.mjs-only shapes with no
+  // ask()-grammar envelope to inherit normalization from (0.9.14 Tier-2
+  // playtest: "waht calls are there" used to hit the grammar wall outright).
+  const q = correctMisspellings(String(query).trim()).toLowerCase().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
   let m;
-  // "what are the imports", "what is the containment", "what are all the calls"
-  if ((m = q.match(/^what\s+(?:are|is)\s+(?:all\s+)?(?:the\s+)?([a-z][a-z-]*?)(?:\s+(?:edges|relationships|relations))?$/))) return m[1];
-  // "what calls are there", "what imports are there"
-  if ((m = q.match(/^what\s+([a-z][a-z-]*?)\s+are\s+there$/))) return m[1];
+  // "what are the imports", "what is the containment", "what are all the calls",
+  // and the texting-shorthand "r" for "are" (0.9.14 Tier-2 playtest §3b spot-check:
+  // "what r the calls" — narrowly scoped to this closed shape, same judgment call
+  // as chat.mjs's own SHORTHAND_CONTRACTIONS for the identity lane: "r" only reads
+  // as "are" right after "what" in one of these curated anchor shapes, so a real
+  // one-letter identifier is never at risk).
+  if ((m = q.match(/^what\s+(?:are|is|r)\s+(?:all\s+)?(?:the\s+)?([a-z][a-z-]*?)(?:\s+(?:edges|relationships|relations))?$/))) return m[1];
+  // "what calls are there", "what imports are there", "what calls r there"
+  if ((m = q.match(/^what\s+([a-z][a-z-]*?)\s+(?:are|r)\s+there$/))) return m[1];
   // "what is calling", "what is importing" (bare gerund, no object)
   if ((m = q.match(/^what\s+(?:is|are)\s+([a-z][a-z-]*ing)$/))) return m[1];
+  // STACCATO RELATION-CHAIN CONTINUATION (0.9.15 Tier-2 playtest, 4th pass): a
+  // rapid-fire short follow-up inside an EXISTING relation-touch chain — "and
+  // calls?", "also tests", "so inherits", "then contains" — has no "about"/
+  // "is"/"are" at all, just a bare connective + the relation word. Without
+  // this, the bare word fell straight through to ask()'s own raw grammar,
+  // which parsed the leading connective ITSELF as the object term (e.g. "and
+  // calls" read as kind=calls object="and", silently resolving "and" via the
+  // standing focus/contextId fallback into an unrelated, honestly-empty-but-
+  // wrong answer) or, worse, matched no shape at all and hit the grammar
+  // wall outright. Scoped to RELATION_TERM's own closed dict downstream (this
+  // function's caller, relationForceAnswer), so an unrelated word or a real
+  // entity name ("and Widget?", "so that") safely falls through unchanged —
+  // only a genuine, already-known relation word is swept up.
+  if ((m = q.match(/^(?:and|also|so|then|now)\s+([a-z][a-z-]*)$/))) return m[1];
   // THE SINGULAR META FORM — "what is a test" / "what is an import". The whole meta
   // shape used to be excluded here to keep the frozen am-meta-imports ambiguity case
   // ("what does imports mean") out; but that case is a DIFFERENT shape (ambiguousParse
@@ -2282,26 +2850,61 @@ function relationTermOf(query, envelope) {
 }
 
 /** A closed "describe"-intent wrapper: "can you describe X for me", "could you
- *  tell me about X", "tell me more about X" → attempt tmct_describe(X). Found
- *  live (playtest sprint round 2, SKILL_PLAYTEST_SPRINT.md): a describe-intent
- *  question wrapped in an ordinary polite request ("can you tell me more about
- *  Controller") fell all the way to the generic wall despite naming a real,
- *  just-listed entity — nothing recognized the wrapper at all. Same closed
- *  lead-in-alternation discipline as GREETING_PREAMBLE_RE/THANKS_PREAMBLE_RE
- *  (normalize.mjs). Deliberately used only as a LAST-RESORT lane (see its call
- *  site below) — "tell me about X" is ALSO the relation/concept force's own
- *  trigger phrase for enumerable concepts ("tell me about inheritance"), so
- *  this must never run before those have had their chance. Trails an optional
- *  "please" as well as "for me" (playtest sprint round 3): this lane reads the
- *  RAW turn text, not normalize.mjs's FILLER_WORDS-stripped one, so "could you
- *  tell me more about Router please" needs its own trailing-politeness strip. */
+ *  tell me about X", "tell me more about X", "what about X" → attempt
+ *  tmct_describe(X). Found live (playtest sprint round 2,
+ *  SKILL_PLAYTEST_SPRINT.md): a describe-intent question wrapped in an
+ *  ordinary polite request ("can you tell me more about Controller") fell all
+ *  the way to the generic wall despite naming a real, just-listed entity —
+ *  nothing recognized the wrapper at all. Same closed lead-in-alternation
+ *  discipline as GREETING_PREAMBLE_RE/THANKS_PREAMBLE_RE (normalize.mjs).
+ *  Deliberately used only as a LAST-RESORT lane (see its call site below) —
+ *  "tell me about X" is ALSO the relation/concept force's own trigger phrase
+ *  for enumerable concepts ("tell me about inheritance"), and "what about X"
+ *  is ALSO discourseRewrite's own trigger for continuing an ask()-shaped prior
+ *  turn — this must never run before those have had their chance. Trails an
+ *  optional "please" as well as "for me" (playtest sprint round 3): this lane
+ *  reads the RAW turn text, not normalize.mjs's FILLER_WORDS-stripped one, so
+ *  "could you tell me more about Router please" needs its own trailing-
+ *  politeness strip.
+ *  "what about X" (0.9.13 Tier-1 playtest): reaches this lane specifically
+ *  when the PRIOR turn was itself a describe-shaped question ("describe Task"
+ *  isn't an ask()-grammar verb, so discourseRewrite's "describe <X>" rewrite
+ *  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. */
 const DESCRIBE_WRAPPER_RE =
-  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?(?:tell\s+me\s+(?:more\s+)?about|describe)\s+(.+?)(?:\s+for\s+me)?(?:\s+please)?\s*\??$/i;
-
-async function describeWrapperAnswer(query, { config, source }) {
-  const m = DESCRIBE_WRAPPER_RE.exec(String(query || "").trim());
-  const term = m?.[1]?.trim();
+  /^(?:(?: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;
+
+/** 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
+ *  set the focus. Never a guess: no standing focus → the lane declines (null),
+ *  same as any unresolvable term. */
+const DESCRIBE_PRONOUN_RE = /^(?:it|that|this|those|them)$/i;
+
+/** STACCATO PRONOUN CONTINUATION (0.9.15 Tier-2 playtest, 4th pass): a rapid-
+ *  fire short follow-up naming no verb at all — "and that?", "also this",
+ *  "so it" — the bare-connective sibling of DESCRIBE_WRAPPER_RE's "what about
+ *  it"/"describe that". Without this, "what calls X" -> "and that?" fell to
+ *  the generic orientation card (isConversational's ≤3-word catch-all caught
+ *  it, and DESCRIBE_WRAPPER_RE requires an actual "about"/"describe" anchor
+ *  word this shape never has) even though the immediately-prior turn had just
+ *  set a real focus a sibling phrasing ("what about it") already resolves
+ *  against cleanly. An optional trailing "one"/"ones" (Tier-2 playtest, 5th
+ *  pass — "also that one?", "and those ones") is at least as natural as the
+ *  bare pronoun and carries no extra meaning beyond it: the capture group
+ *  stays the pronoun alone, so DESCRIBE_PRONOUN_RE's downstream test is
+ *  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();
+  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;
+  }
   try {
     const text = await dispatchTool("tmct_describe", { symbol: term }, { config, source });
     return text ? { text } : null;
@@ -2398,7 +3001,7 @@ async function conceptForceAnswer(query, envelope, { graph, config, source, memo
  *  otherwise the unchanged dispatchTool path (which also yields the no-graph error).
  *  A hit updates the focus to the resolved object. Grammar miss / ToolError → a
  *  normal answer, never a crash. */
-async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace }) {
+async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null }) {
   const ts = new Date().toISOString();
   // DISCOURSE ANAPHORA (CHATBENCH_006 levers 1+2): a follow-up like "which of those
   // are tested" / "how many of those" / "count them" filters or counts the PREVIOUS
@@ -2414,7 +3017,29 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // The query the ENGINE parses: a "what about X" continuation is rewritten to the
   // prior shape with X swapped in; everything else parses verbatim. The record and
   // transcript keep the user's ACTUAL words (`query`), only the parse target changes.
-  const askQuery = discourseRewrite(query, last) ?? query;
+  let askQuery = discourseRewrite(query, last) ?? query;
+  // IMPLICIT ANAPHORIC COUNT (Tier-2 playtest, 5th pass): "how many are tested" /
+  // "and how many are tested" drops the "of those/them" a fuller phrasing carries
+  // — ask()'s own anaphora node (parseAnaphora) already understands "how many of
+  // those are tested" perfectly, it simply never SEES this elliptical spelling
+  // (ANAPHORA_TRIGGERS requires an explicit pronoun). Insert the elided "of
+  // those" here, the same way discourseRewrite rewrites "what about X" —
+  // UNCONDITIONALLY (not gated on `prev.length`): a genuinely bare "how many
+  // are tested" with no antecedent at all still reaches the anaphora node this
+  // way, which itself honestly degrades to "needs a previous answer to refer
+  // to" (evalAnaphora's own no-prev branch) — a strictly better outcome than
+  // leaving the raw ellipsis unrewritten, which used to fall through to the
+  // ordinary clause grammar and misparse "and" as the object ('no module
+  // matching "and many" found').
+  if (IMPLICIT_ANAPHORA_COUNT_RE.test(String(askQuery).trim())) {
+    // Strip the leading connective too ("and how many are tested" -> "how many
+    // of those are tested") — left in place, it breaks the anaphora node's own
+    // AGGREGATE_TRIGGERS match on "how many" (anchored at the string start),
+    // silently degrading the count into a bare list of the filtered set.
+    askQuery = String(askQuery).trim()
+      .replace(/^(?:and|so|then|also)\s+/i, "")
+      .replace(/how many\s+/i, "how many of those ");
+  }
   // W2: the explicit recall forms are answered from memory's folded blocks, never
   // the graph. Gated on memoryDir — a bare runTurn (no session shell) stays pure.
   if (memoryDir && RECALL_ASK_RE.test(String(query).trim())) {
@@ -2523,13 +3148,59 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // codebase", "how do i start") → a summary / orientation, answered before the
   // fact-dump readers so "what do you know" gets a summary, not raw facts.
   if (miss) {
-    const meta = await metaLane(query, { graph, memoryDir, last });
+    const meta = await metaLane(query, { graph, memoryDir, last, templates, vocabHint });
     if (meta) {
       answer = meta.text; via = meta.via; recordMiss = false; handled = true;
       note(trace, `lane: (1) META/SELF — bare self/session question recognized, answered via="${meta.via}"`);
     }
   }
-  if (!handled && miss && !envelope?.parsed && isConversational(query)) {
+  // "what about X" with a genuine PRIOR turn to continue (0.9.13 Tier-1 playtest)
+  // is exempt from the conversational catch-all even when short/non-codeish
+  // ("what about that", "what about Task" — no dotted/camel token, ≤3 words):
+  // isConversational() can't see that ask() ALREADY tried discourseRewrite above
+  // and that the describe-wrapper rescue (4d) hasn't had its turn yet — without
+  // this exemption, EVERY "what about X" continuation whose prior turn was itself
+  // a describe-shaped question (discourseRewrite can't rewrite "describe X", so it
+  // always misses) or whose swapped-in subject is a bare Capitalized/pronoun term
+  // fell straight to the generic orientation card instead of reaching (4d).
+  // Same exemption for the bare-connective sibling shape ("and Widget?", "also
+  // app/lib/b.mjs" — no "about" at all, STACCATO_SWAP_RE above), gated the
+  // SAME way discourseRewrite gates it: the swapped-in word must itself be
+  // unambiguously code-ish, so ordinary discourse ("and then?", "so what")
+  // never trips this exemption.
+  const staccatoSwapMatch = String(query).match(STACCATO_SWAP_RE);
+  const isStaccatoSwap = !!(last?.query && staccatoSwapMatch && NAME_TOKEN_RE.test(staccatoSwapMatch[1]?.trim() || ""));
+  const isWhatAboutContinuation = !!(last?.query && WHAT_ABOUT_RE.test(String(query))) || isStaccatoSwap;
+  // Same exemption for the sibling shape "describe it"/"tell me about that"
+  // (0.9.13 Tier-1 playtest): a bare-pronoun describe/tell-me-about is exactly
+  // as short and non-codeish as "what about it", and needs the SAME deferral to
+  // reach describeWrapperAnswer's now-focus-aware pronoun resolution (4d) —
+  // WITHOUT this, "describe Widget" -> "describe that" (a natural drill-down
+  // re-ask) fell to the orientation card even though the standing focus made it
+  // perfectly answerable. Gated on an actual standing focus, same honest-decline
+  // discipline as describeWrapperAnswer itself.
+  const describeWrapperMatch = DESCRIBE_WRAPPER_RE.exec(String(query).trim()) || STACCATO_PRONOUN_RE.exec(String(query).trim());
+  const isDescribePronounContinuation = !!(focus?.label && describeWrapperMatch && DESCRIBE_PRONOUN_RE.test(describeWrapperMatch[1]?.trim() || ""));
+  // A bare/wrapped "explain X" (0.9.14 Tier-2 playtest, second pass) needs the
+  // SAME deferral, and for a stronger reason than the two above: "explain"
+  // isn't a VERB_TO_KIND word at all, so ask() never even ATTEMPTS a parse
+  // (envelope.parsed is null unconditionally for this shape, not merely on a
+  // miss) — a short "explain cochange" (2 words) or politeness-wrapped
+  // "please explain cochange" (3 words) always trips isConversational's ≤3-
+  // word heuristic and never once reaches the relation/concept force below,
+  // which is squarely built to answer exactly this shape. Unlike the two
+  // exemptions above, this one needs no prior-turn/focus context — "explain
+  // X" is a complete, self-contained ask on its own.
+  const isExplainTouch = EXPLAIN_TOUCH_RE.test(String(query).trim());
+  // Staccato negation ("not that one", "not Widget then" — Tier-2, 5th pass)
+  // needs the SAME deferral: "not those" (2 words) / "not that one" (3 words)
+  // both trip isConversational's ≤3-word catch-all before nudgeAnswer's own
+  // STACCATO_NEGATION_RE branch (4c, below) ever gets a turn. Gated on the
+  // shape alone (not a focus/prev precondition) — nudgeAnswer's negation
+  // branch ALWAYS returns a tailored nudge for this shape, never null, so
+  // deferring here never strands the turn with nothing having claimed it.
+  const isStaccatoNegation = STACCATO_NEGATION_RE.test(String(query).trim());
+  if (!handled && miss && !envelope?.parsed && isConversational(query) && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation) {
     // A conversational miss (a greeting, "what can you do", a very short non-code
     // line) gets the friendly orientation (module-aware: empty → --repo/tmct init).
     // Bug B1 (0.8.2 follow-up): this branch carries via:"template" and never
@@ -2549,7 +3220,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // structural (by construction, not word-count guesswork); its own composed
     // answer — hit, honest empty, or "it needs a referent" — is always more
     // truthful than the orientation card.
-    const orientation = orientationAnswer(templates, graph);
+    const orientation = orientationAnswer(templates, graph, vocabHint);
     const repeat = last?.answer === orientation;
     answer = repeat ? ORIENTATION_REPEAT_ONELINER : orientation;
     via = "template"; handled = true;
@@ -2729,7 +3400,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 });
+    const described = await describeWrapperAnswer(query, { config, source, focus: newFocus });
     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");
@@ -2806,7 +3477,25 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     : (envelope
       ? { traversal: envelope.traversal || null, matches: envelope.matches || [], ...(pending ? { pending } : {}) }
       : (pending ? { traversal: null, matches: [], pending } : null));
-  return { answer, logLines, record, focus: newFocus, detail };
+  // MULTI-HOP STACCATO CHAIN CONTINUATION (Tier-2 playtest, 5th pass): when
+  // discourseRewrite actually substituted a new subject into the PRIOR
+  // query's shape ("and Widget?" -> "what calls Widget") and the rewritten
+  // query STRUCTURALLY PARSED (envelope.parsed stood — a real AST, whether it
+  // went on to a hit or an honest empty; "miss" in this engine's own
+  // convention covers BOTH a genuine grammar failure AND a structurally valid
+  // empty result, so `recordMiss` alone can't distinguish them here), thread
+  // the RECONSTRUCTED positive query forward as the effective `last.query`
+  // the NEXT turn's own discourseRewrite reads — not the raw staccato text
+  // itself. Without this, a 3rd staccato swap in a row ("what calls X" ->
+  // "and Widget?" -> "and Button?") tried to rewrite off "and Widget?" (the
+  // 2nd turn's own verbatim staccato input, which has no clause shape of its
+  // own), corrupting the 3rd swap into a nonsense re-ask ("and Button?" with
+  // "Widget" replaced by "Button" — never a real query) instead of correctly
+  // continuing from "what calls Widget". The verbatim text stays on
+  // `record.query`/the transcript untouched; only the swap-chain
+  // CONTINUATION base changes.
+  const effectiveQuery = (askQuery !== query && envelope?.parsed) ? askQuery : null;
+  return { answer, logLines, record, focus: newFocus, detail, effectiveQuery };
 }
 
 /** A non-ask, non-dispatch chat turn (count answer, /stats) — the same
@@ -3005,7 +3694,7 @@ function morePage(query, { last, focus }) {
   return turn;
 }
 
-export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false } = {}) {
+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();
   const templates = await chatTemplates(); // failure-tolerated: null degrades, never throws
   // narrate mode: allocate the mutable trace array ONLY when on (`null` when off,
@@ -3015,7 +3704,12 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // the narrate:false path allocates nothing extra and renders byte-identically to
   // before this feature existed — see the "---- narrate mode ----" section above.
   const trace = narrate ? [] : null;
-  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate };
+  // vocabHint: createSession computes this ONCE per session (a marker-file check)
+  // and threads it in; a direct runTurn() caller (tests, library use) that doesn't
+  // pass one gets it computed here instead, so "try this vocabulary example" is
+  // never wrong regardless of caller.
+  const resolvedVocabHint = vocabHint ?? vocabExampleHint(await hasSeededVocabulary(memoryDir));
+  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint };
   // A DISPATCHED turn (count / slash-command / ask) becomes the new "last answer"
   // that why/say-more re-renders; a conversational turn does not (it preserves it).
   // FINISH SEAM (PLAN_RESPONSE_FINISHING §"Where it lives"): every dispatched turn's
@@ -3028,7 +3722,13 @@ 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 });
-    const nextLast = { query: line, answer: finished.answer, detail: finished.detail ?? null };
+    // 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 —
+    // see runAsk's docblock above its return statement. Every other turn type
+    // (commands, plain counts, misses) carries no such field, so `line` — the
+    // existing, unchanged behavior — stands.
+    const nextLast = { query: finished.effectiveQuery ?? line, answer: finished.answer, detail: finished.detail ?? null };
     return { ...withNarration(finished, trace, fallbackGoal), last: nextLast };
   };
 
@@ -3168,6 +3868,43 @@ async function seedBootstrapMemory(repo) {
   }
 }
 
+/** Whether THIS repo's memory actually carries the corpus seed — the marker is
+ *  authoritative regardless of whether the CURRENT run performed the seeding or
+ *  an earlier run (or `tmct init`) did (seedBootstrapMemory short-circuits on an
+ *  existing marker without re-reading the slice). The one signal every "try this
+ *  vocabulary example" surface must check before offering a term-specific query —
+ *  see vocabExampleHint. A cheap fs check, negligible next to the per-turn
+ *  template load. */
+async function hasSeededVocabulary(repo) {
+  if (!repo) return false;
+  try { await readFile(join(repo, SEED_MARKER_REL), "utf8"); return true; }
+  catch { return false; }
+}
+
+/** A "try this" vocabulary-example clause that's PROVABLY correct in the session
+ *  it's shown, mirroring the discipline orientationExamples() already applies to
+ *  structural examples (never offer an example that isn't confirmed to resolve).
+ *  `cache` is confirmed live: present in corpus/seon/definitions.jsonl, backed by
+ *  a corpus:seon concept fact, and a recognized lexicon noun — but only actually
+ *  answerable once the seed has run. When it hasn't (TMCT_NO_SEED=1,
+ *  seed.enabled=false, or corpus load failure), offering it would be a lie worse
+ *  than no example — swap to an unconditionally-true pointer instead (the teach
+ *  lane and `tmct init` both work with zero preconditions). Computed ONCE per
+ *  session (createSession), not per turn.
+ *  The unseeded branch's teach clause is a CONCRETE pair too, for the same
+ *  reason `cache` is concrete in the seeded branch: playtest found that an
+ *  abstract "every X is a Y" invites a curious user to fill X/Y with an
+ *  intuitive-but-unknown word ("every cache is a thing" — "thing" isn't in
+ *  the closed ACE lexicon) and hit the teach-miss dead-end right after being
+ *  offered the pattern. "every bug is an issue" is confirmed to parse and
+ *  store (both `bug` and `issue` are declared lexicon nouns — see
+ *  test/chatflow-tier0.test.mjs), so the offer resolves if copied verbatim. */
+function vocabExampleHint(seeded) {
+  return seeded
+    ? 'Try "what is a cache" for general vocabulary.'
+    : 'Run `tmct init` to seed a starter vocabulary, or teach me directly, e.g. "every bug is an issue".';
+}
+
 /** Trim a focus label for the prompt so a long module path can't run the line off. */
 const shortLabel = (l) => { const s = String(l); return s.length > 40 ? "…" + s.slice(-39) : s; };
 const promptFor = (focus) => (focus ? `tmct(${shortLabel(focus.label)})> ` : PROMPT);
@@ -3323,6 +4060,13 @@ export async function createSession({
   if (empty && String(env.TMCT_NO_SEED || "") !== "1") {
     seeded = await seedBootstrapMemory(repo);
   }
+  // vocabHint: computed ONCE per session (not per-turn — see runTurn's own
+  // per-call fallback for direct/library callers). `seeded` is only truthy when
+  // THIS run performed the seeding; a repo seeded by an EARLIER run (or `tmct
+  // init`) still needs the marker check, so this covers both — see
+  // hasSeededVocabulary's docblock.
+  const vocabSeeded = Boolean(seeded) || (await hasSeededVocabulary(repo));
+  const vocabHint = vocabExampleHint(vocabSeeded);
   // #3/#5: 0 modules means no code graph to answer structure questions from —
   // whether the graph file is absent (empty bootstrap) OR present with no code
   // entities (the degenerate trap). Both get orienting, non-over-promising banner
@@ -3338,9 +4082,11 @@ export async function createSession({
     // is the TOTAL appended, split into the curated SEON ontology + the ConceptNet band.
     ...(seeded ? [`seeded ${seeded.appended} starter facts (${seeded.seon} curated SEON + ${seeded.conceptnet} ConceptNet) — /memory to inspect`] : []),
     // no code graph → point at how to GET one (a graph producer / --repo / the shipped
-    // example), honest that `tmct init` seeds VOCABULARY, not a code graph, and at what
-    // IS answerable now. tmct reads graphs; it never indexes code itself.
-    ...(noCodeGraph ? ['for code structure, point me at a .tmct/graph.json with --repo <path> or try `npm run example:mini` (tmct reads graphs, it doesn\'t index code); `tmct init` only seeds vocabulary — try "what is a cache"'] : []),
+    // example), and at what IS answerable now — `vocabHint` is only ever a term
+    // confirmed to resolve in THIS session's actual seed state (see vocabExampleHint),
+    // never a hardcoded example that might not have been seeded. tmct reads graphs;
+    // it never indexes code itself.
+    ...(noCodeGraph ? [`for code structure, point me at a .tmct/graph.json with --repo <path> or try \`npm run example:mini\` (tmct reads graphs, it doesn't index code). ${vocabHint}`] : []),
     "pass --repo <path> to target a different repo",
     "ask a question, or /help for commands (/stats for an overview) — /exit to leave",
   ];
@@ -3370,7 +4116,7 @@ export async function createSession({
     async turn(line) {
       let result;
       try {
-        result = await runTurn(line, { config, source, graph, focus, last, memoryDir: repo, sessionId, env, lexicon, narrate: narrateOn });
+        result = await runTurn(line, { config, source, graph, focus, last, memoryDir: repo, sessionId, env, lexicon, narrate: narrateOn, vocabHint });
       } catch (e) {
         const ts = new Date().toISOString();
         const message = e instanceof Error ? e.message : String(e);