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

package/src/chat.mjs

@@ -51,9 +51,9 @@ 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
@@ -333,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"
@@ -386,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
@@ -397,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".`;
@@ -519,8 +595,24 @@ const IDENTITY_PHRASES = [
   /^(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)? what (you are|this is)\??$/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,
@@ -723,13 +815,37 @@ function classifyConversational(phrase) {
   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"/"wat r u"/"byee" tier. Restricted to
- *  short (≤4-word), non-code-ish inputs (looksCodeish, shared with
+ *  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 q = collapseRuns(raw.toLowerCase().replace(/[.!?]+$/, "").trim());
+  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)));
@@ -1104,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 }) {
@@ -1152,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,
   };
@@ -1177,13 +1347,18 @@ const META_ORIENT_RE = /^(?:what(?:'s| is| are)?\s+this(?:\s+(?:app|codebase|rep
  *  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. */
+ *  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"'
-      : 'run `tmct init` to seed a starter vocabulary, or teach me directly with "every X is a Y"';
+      : '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));
@@ -1306,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) {
@@ -1320,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: "
@@ -1341,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;
 }
 
@@ -1683,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
@@ -1866,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);
@@ -2273,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
@@ -2284,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);
 }
 
@@ -2405,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) {
@@ -2426,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
@@ -2451,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;
@@ -2583,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())) {
@@ -2698,7 +3154,53 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       note(trace, `lane: (1) META/SELF — bare self/session question recognized, answered via="${meta.via}"`);
     }
   }
-  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
@@ -2898,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");
@@ -2975,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
@@ -3202,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 };
   };
 
@@ -3364,11 +3890,19 @@ async function hasSeededVocabulary(repo) {
  *  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. */
+ *  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 with "every X is a Y".';
+    : '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. */