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

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
@@ -218,6 +218,53 @@ function withNarration(result, trace, fallbackGoal) {
   return { ...result, answer, logLines };
 }
 
+/** FEATURE B ("Goal (inferred): …"): an ALWAYS-ON, single short goal line —
+ *  independent of the --narrate/TMCT_NARRATE opt-in debug trace above (which
+ *  stays exactly as-is: the FULL "--- narrate ---" block, off by default).
+ *  What the operator actually wants now is much lighter than that full dump:
+ *  one line, on every STRUCTURAL/query-shaped answer, APPENDED (blank-line
+ *  separated) so it never reads as part of the substantive answer — and so it
+ *  never disturbs the many existing START-anchored assertions this codebase's
+ *  own test suite pins composed answers with (see withGoalLine's own docblock,
+ *  just below, for why appended rather than led-with).
+ *
+ *  `result.goal` is set ONLY by runAsk (see its own docblock at its return
+ *  statement) — a plain count, a slash-command or a teach confirmation never
+ *  carries the field, so this is a no-op for those turn types BY
+ *  CONSTRUCTION, not a special-cased suppression list here. Also a no-op when
+ *  `result.goal` is null/empty — deduceGoalFromParsed's own "nothing to
+ *  bucket on" signal (a total grammar miss, or a would-miss a conversational-
+ *  in-ask lane answered) — so an unclear turn never grows a "Goal (inferred):
+ *  unclear" line, which would be worse than showing nothing.
+ *
+ *  Applied AFTER finish() (so the appended line is never grammar-rewritten) and
+ *  BEFORE `last` is captured in runTurn's withLast — mirrors withNarration's
+ *  own after-finish/never-touches-`last` discipline (see its docblock above),
+ *  so a goal-prefixed turn's own repeat-detection / why/say-more re-render
+ *  compares the EXACT SAME `last.answer` a goal-line-off run would have
+ *  produced. Purely additive to what's PRINTED, never to what's REMEMBERED —
+ *  the same contract narrate uses, a second, independent mechanism reusing
+ *  the same discipline (composes cleanly with narrate: a narrated turn gets
+ *  BOTH the short line up top and the full trace block below, never a
+ *  conflict). */
+function withGoalLine(result) {
+  const goal = result?.goal;
+  if (!goal) return result;
+  // APPENDED (not prepended), blank-line separated: this codebase's existing
+  // test suite pins a large number of composed answers with a START-anchored
+  // (`^…`, no trailing `$`) regex — appending keeps every one of those intact
+  // (the answer still STARTS with the real content) while a prepend would have
+  // broken them all. Still reads as clearly separate, non-substantive trailer
+  // text — the same "additive, never mixed into the substantive answer" intent
+  // a leading line would have given, just from the other end.
+  const suffix = `Goal (inferred): ${goal.charAt(0).toUpperCase()}${goal.slice(1)}.`;
+  const answer = `${result.answer}\n\n${suffix}`;
+  const logLines = Array.isArray(result.logLines)
+    ? result.logLines.map((l) => (l === result.answer ? answer : l))
+    : result.logLines;
+  return { ...result, answer, logLines };
+}
+
 /** Slash-command → (dispatchTool name, arg key). Arg keys are the EXACT ones the
  *  server.mjs dispatchTool switch reads (members/subclasses take `class`;
  *  impact/exports take `module`; architecture takes `package`; search takes
@@ -333,6 +380,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 +441,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 +515,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".`;
@@ -434,6 +557,47 @@ async function countFromFacts(graph, memoryDir, query) {
   return null;
 }
 
+// ---- Feature A point 4: "how many Xs are Ys" — literal recall of a taught
+// quantifier ("some"/"a few"/"every"), NEVER real cardinality counting
+// (consistent with this file's "grounded or honest miss" philosophy). The
+// SOME_A_FEW_RE / unknownSubjectFallback / assertTurn's own "every"-quantifier
+// follow-up (below) are what STORE the quantifier this reads back.
+//
+// CRITICAL ORDERING NOTE: dispatched explicitly ahead of answerCount in
+// runTurn (mirroring answerMemoryCount's own precedent, just below) —
+// answerCount's own noun-scan regex greedily grabs the FIRST word after "how
+// many" as a literal noun to count and would otherwise short-circuit to an
+// "I can't count 'Xs'" miss before this lane ever got a turn.
+//
+// AUTHORITY GATE (avoids shadowing real graph counts): claims authority
+// (always returns a non-null string — either the quantifier or an honest "I
+// don't know") ONLY when (a) the subject does NOT name a real graph-countable
+// class (COUNT_NOUNS — the same guard countFromFacts uses, so a corpus-seeded
+// fact that happens to share a subject word like "module" never shadows a
+// real "how many modules …" count) AND (b) tmct has SOME isa-family fact
+// about that subject at all (a subject never taught anything, e.g. "classes"
+// in "how many classes are there", falls through to answerCount's real
+// graph-cardinality count untouched — same honest-decline discipline as
+// every other lane here).
+const HOW_MANY_ARE_RE = /^how\s+many\s+([\w-]+)\s+(?:are|is)\s+(.+?)[?.!\s]*$/i;
+async function answerQuantifierRecall(memoryDir, query) {
+  if (!memoryDir) return null;
+  const m = String(query).trim().match(HOW_MANY_ARE_RE);
+  if (!m) return null;
+  const asked = m[1].toLowerCase();
+  if (COUNT_NOUNS[asked]) return null; // a real graph-countable class — answerCount owns it
+  let normFactTerm;
+  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  const subjVariants = factTermVariants(normFactTerm, asked);
+  const rows = (await factRows(memoryDir)).filter((f) => ISA_PREDICATES.has(f.predicate) && subjVariants.has(f.subject));
+  if (!rows.length) return null; // never heard of this subject at all — let answerCount own the shape
+  const objVariants = factTermVariants(normFactTerm, m[2]);
+  const hit = rows.filter((f) => objVariants.has(f.object)).sort((a, b) => (b.trust ?? 0) - (a.trust ?? 0))[0];
+  const q = hit?.quantifier;
+  if (!q) return "I don't know — I was never told a quantifier for that.";
+  return `${q.charAt(0).toUpperCase()}${q.slice(1)}.`;
+}
+
 // ---- memory-store counts (the .tmct/memory graph, distinct from the code graph
 // answerCount reads) — so "how many facts do you know" is answerable, consistent
 // with what `/memory` advertises. The code graph owns the structural kinds
@@ -519,8 +683,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 +903,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)));
@@ -1056,6 +1260,12 @@ const QUESTION_LEAD_RE = /^(?:what|who|which|where|when|why|how|is|are|do|does|d
 // The teach lane's fact predicates (rendered via FACT_PREDICATE_PHRASES).
 const OWNED_BY_PREDICATE = "mgx:ownedBy";
 const HAS_PROPERTY_PREDICATE = "mgx:hasProperty";
+// Class-membership — the SAME predicate family the ACE grammar's own
+// subClassOf pattern emits (grammar/ace.mjs); named here too (Feature A) so
+// the new direct-write paths below (the unknown-subject fallback, the plural
+// "some/a few Xs are Ys" shape) stay obviously in that same family rather than
+// re-typing the CURIE string at each call site.
+const SUBCLASS_PREDICATE = "rdfs:subClassOf";
 
 /** "<Name> owns/maintains <X>" — the ownership teach declarative. <Name> is one
  *  or two name tokens, <X> one code-ish token (a path, a file, a symbol). The
@@ -1078,7 +1288,7 @@ const teachProvenanceTag = (sessionId, ts) => `teach:chat${sessionId ? `:${sessi
 /** Reify one teach-lane fact + confirm (shared by the property and ownership
  *  frames). Lazy + failure-tolerated: a write failure degrades to null (the
  *  teach-miss text stands), never a crash. */
-async function teachFact(memoryDir, sessionId, { subject, predicate, object }) {
+async function teachFact(memoryDir, sessionId, { subject, predicate, object, quantifier = "" }) {
   try {
     const { appendFact, normFactTerm } = await import("./memory/core.mjs");
     const s = normFactTerm(subject);
@@ -1087,6 +1297,7 @@ async function teachFact(memoryDir, sessionId, { subject, predicate, object }) {
     await appendFact(memoryDir, {
       subject: s, predicate, object: o,
       provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+      ...(quantifier ? { quantifier } : {}),
     });
     const phrase = FACT_PREDICATE_PHRASES[predicate] || predicate;
     return { text: `noted — remembered: ${s} ${phrase} ${o}`, via: "assert", miss: false };
@@ -1095,6 +1306,99 @@ async function teachFact(memoryDir, sessionId, { subject, predicate, object }) {
   }
 }
 
+// ---- FEATURE A (0.9.x): teach new terms + quantifier phrasings ("every X is
+// a/an Y", "some Xs are Ys", "your X is a/an Y", "X is Y", "a few Xs are
+// Ys") + "how many Xs are Ys" recall. Design (from two prior read-only
+// investigations, live-verified): the memory Facts store and EVERY read path
+// (factAnswer, factReadBack, the 2-hop findIsaChain proof-chase) already work
+// generically over ANY subject string — the ONLY thing stopping e.g. "redis is
+// a cache" from being remembered is that parseAce's resolveNP (grammar/ace.mjs)
+// only resolves subjects/objects against the closed 180-word lexicon-core.json
+// noun list, so an unknown SUBJECT becomes residue and the whole sentence is
+// rejected even though the OBJECT ("cache") is a perfectly good known term. The
+// fix below is write-side only and deliberately NARROW: only the SUBJECT gets
+// a free pass, never the OBJECT — this is not a general lexicon bypass, it's
+// one additional storable shape alongside the ACE grammar's own 8 patterns. ----
+
+/** Naive plural → singular fold for the "some/a few Xs are Ys" surface forms
+ *  (mirrors factTermVariants' own naive -es/-s stripping, below, but returns
+ *  ONE canonical spelling to STORE rather than a lookup Set of candidates to
+ *  match against). Deliberately tiny, no NLP — a stray false fold on an
+ *  already-singular noun ending in "s" is a known, accepted limitation of this
+ *  same naive scheme used elsewhere in this file (factTermVariants). */
+function singularizeSurface(word) {
+  const w = String(word || "").trim();
+  if (/[a-z]ies$/i.test(w)) return `${w.slice(0, -3)}y`;
+  if (/(ses|xes|zes|ches|shes)$/i.test(w)) return w.slice(0, -2);
+  if (/[a-z]s$/i.test(w) && !/ss$/i.test(w)) return w.slice(0, -1);
+  return w;
+}
+
+/** "some Xs are Ys" / "a few Xs are Ys" — the plural class-membership
+ *  quantifier shape. Captures the quantifier word itself (group 1) alongside
+ *  the plural subject/object (groups 2/3); singularized before storage/lookup. */
+const SOME_A_FEW_RE = /^(some|a few)\s+([\w-]+)\s+are\s+([\w-]+)$/i;
+
+/** "(every|each|all|a|an )?X is/are (a|an )?Y" — the shape the unknown-subject
+ *  fallback recognizes (group 2 = X, group 3 = Y); group 1 (when present)
+ *  names the determiner, so the caller can tell a genuine "every" universal
+ *  apart from a singular/specific-entity "a"/bare reading (only "every" gets a
+ *  recorded quantifier here — this function's OWN caller passes it through to
+ *  teachFact; assertTurn, below, records the same "every" quantifier
+ *  independently for the pre-existing ACE-success path). Single-token X and Y
+ *  only — the same fragment scope parseAce's own copula patterns cover, just
+ *  with X's lexicon-membership requirement lifted. */
+const UNKNOWN_SUBJECT_RE = /^(every\s+|each\s+|all\s+|a\s+|an\s+)?([\w-]+)\s+(?:is|are)\s+(?:an?\s+)?([\w-]+)$/i;
+
+/** The unknown-SUBJECT direct-write fallback (point 1 + point 2's bare-property
+ *  extension): tried ONLY after the real ACE grammar (assertTurn) has already
+ *  had its turn and declined. Declines itself (returns null, never a guess)
+ *  when:
+ *    - the payload doesn't fit the plain single-token "X is/are Y" shape at all
+ *      (a multi-word subject, a relation/cardinality/etc. sentence — those stay
+ *      the ACE grammar's territory, or the wrapped multi-word TEACH_PROPERTY_RE
+ *      path below, unchanged);
+ *    - X is actually a KNOWN lexicon word — then the ACE grammar's own miss was
+ *      a real structural/vocabulary problem elsewhere (e.g. Y itself unknown as
+ *      the WRONG part of speech), never silently reinterpreted through this
+ *      narrow exception;
+ *    - Y resolves as NEITHER a known noun NOR a known adjective — the OBJECT
+ *      must still be a term tmct actually knows; an unknown Y stays an honest
+ *      miss (never a guess), exactly like the pre-existing "monkey is an
+ *      animal" case.
+ *  Y resolving as a NOUN writes rdfs:subClassOf (mirrors the ACE grammar's own
+ *  subClassOf/typeAssertion pattern); Y resolving as an ADJECTIVE (and not also
+ *  a noun) writes mgx:hasProperty (mirrors the wrapped "remember that X is
+ *  deprecated" property frame — reused here for the bare/unwrapped form too,
+ *  since the free pass is about the SUBJECT, not about the "remember that"
+ *  wrapper). Only the "every" determiner records a quantifier (point 3: "a"/
+ *  bare/"your" read as one specific entity, not a class-level generalization). */
+async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }) {
+  if (!memoryDir) return null;
+  const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
+  if (!m) return null;
+  const [, det, subjectRaw, objectRaw] = m;
+  const { loadLexicon, lookupNoun, lookupAdjective, classify } = await import("./grammar/lexicon.mjs");
+  const lex = lexicon || loadLexicon();
+  // A known X's own ACE miss is a real miss — never silently reinterpreted here.
+  if (classify(subjectRaw, lex)) return null;
+  const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
+  if (lookupNoun(lex, objectRaw)) {
+    return teachFact(memoryDir, sessionId, {
+      subject: subjectRaw, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
+    });
+  }
+  if (lookupAdjective(lex, objectRaw)) {
+    // property assertions are about ONE specific entity — never a quantifier,
+    // even when phrased with "every" (point 3).
+    return teachFact(memoryDir, sessionId, {
+      subject: subjectRaw, predicate: HAS_PROPERTY_PREDICATE, object: objectRaw,
+    });
+  }
+  return null; // Y unknown too — decline honestly, never guess
+}
+
+
 /** Sentence forms to try asserting for a teach payload: the payload as-is, and
  *  (if it carries no determiner) its "every …" universal — the ACE-OWL shape the
  *  grammar actually lands. */
@@ -1104,16 +1408,38 @@ 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 }) {
-  const raw = String(query).trim();
-  const m = raw.match(TEACH_RE);
-  const wrapped = m ? m[1].trim() : null;
+  const rawInput = String(query).trim();
+  const m = rawInput.match(TEACH_RE);
+  const wrappedInput = m ? m[1].trim() : null;
+  // "your X is a/an Y" (Feature A) — a plain casual synonym for "a/an X is a
+  // Y": no special second-person semantics, so rewrite it to the ordinary
+  // indefinite-article determiner UP FRONT, before any downstream regex/ACE
+  // parsing ever sees it (ACE itself has no notion of "your" as a
+  // determiner). Only a LEADING "your" is rewritten, so this can't misfire on
+  // a "your" appearing mid-sentence; applied to both the bare and the
+  // remember-wrapped surface.
+  const stripYour = (s) => (s == null ? s : s.replace(/^your\s+/i, "a "));
+  const raw = stripYour(rawInput);
+  const wrapped = stripYour(wrappedInput);
 
   // OWNERSHIP — "<Name> owns/maintains <X>", bare or remember-wrapped. The bare
   // form is double-gated: a Capitalized name AND no interrogative lead, so the
@@ -1127,6 +1453,32 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
     if (stored) return stored;
   }
 
+  // "some Xs are Ys" / "a few Xs are Ys" (Feature A) — the plural class-
+  // membership quantifier shape. ACE has no quantifier-phrase pattern at all
+  // (parseAce never even attempts a fit), so this is ALWAYS a direct write,
+  // never routed through assertTurn below. Wrapper-optional, like the
+  // "every X is a Y" baseline — a plural "some/a few" claim reads as an
+  // ordinary declarative teach the same way "every" always has. The OBJECT
+  // still has to be a known lexicon noun (the same "subject gets the free
+  // pass, object doesn't" discipline as unknownSubjectFallback below) — an
+  // unknown object falls through to the generic honest-miss cascade at the
+  // bottom of this function, same as every other unstorable teach.
+  const someSrc = wrapped ?? raw.replace(/[.!?]+\s*$/, "");
+  const someMatch = memoryDir && !QUESTION_LEAD_RE.test(someSrc) ? someSrc.match(SOME_A_FEW_RE) : null;
+  if (someMatch) {
+    const quantifier = someMatch[1].toLowerCase();
+    const subject = singularizeSurface(someMatch[2]);
+    const object = singularizeSurface(someMatch[3]);
+    const { loadLexicon, lookupNoun } = await import("./grammar/lexicon.mjs");
+    const lex = lexicon || loadLexicon();
+    if (lookupNoun(lex, object)) {
+      const stored = await teachFact(memoryDir, sessionId, {
+        subject, predicate: SUBCLASS_PREDICATE, object, quantifier,
+      });
+      if (stored) return stored;
+    }
+  }
+
   let payload = null;
   if (wrapped && /\b(?:is|are)\b/i.test(wrapped)) payload = wrapped;
   else if (BARE_DECLARATIVE_RE.test(raw) && !QUESTION_LEAD_RE.test(raw)) payload = raw;
@@ -1135,9 +1487,20 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // the "noted — remembered …" confirmation or null (grammar miss / unknown words).
   if (memoryDir) {
     for (const cand of assertCandidates(payload)) {
+      // assertTurn ITSELF records the "every" quantifier (point 3) on a plain
+      // universal success, so every caller (this loop AND the top-level
+      // declarative-sentence dispatch in runTurn) gets it uniformly.
       const stored = await assertTurn(cand, { memoryDir, sessionId, focus: null, lexicon });
       if (stored) return { text: stored.answer, via: "assert", miss: false };
     }
+    // BUG "redis" fix (Feature A point 1): the real ACE grammar just declined
+    // (unknown words / not the membership shape) — try the narrow unknown-
+    // SUBJECT direct-write fallback before falling to the honest-miss cascade.
+    // Covers BOTH the bare and the wrapped surface (payload is already
+    // unwrapped either way) — see unknownSubjectFallback's own docblock for
+    // the exact narrowing rules (object must still be known, etc.).
+    const fallback = await unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon });
+    if (fallback) return fallback;
     // PROPERTY teach — "remember/note that <X> is <adjective>": wrapper-REQUIRED
     // (a bare "X is deprecated" is never silently reified), and only after the
     // ACE grammar declined (unknown words / not the membership shape), so a
@@ -1152,10 +1515,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 +1582,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 +1716,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 +1780,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 +1805,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 +2157,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 +2380,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 +2807,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 +2837,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 +2966,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 +3037,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 +3085,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 +3252,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())) {
@@ -2677,10 +3368,16 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // completely different lane — an intent lane's own goal note, when it pushes one,
   // stays the more specific of the two since bucketTrace keeps every "goal:" line and
   // renderNarration shows them all, most-specific-last-written).
-  {
-    const deduced = deduceGoalFromParsed(envelope?.parsed);
-    note(trace, `goal: ${deduced ?? "unclear — the phrasing didn't resolve to a known query shape"}`);
-  }
+  //
+  // FEATURE B: `deduced` (declared here, not block-scoped) also rides the
+  // returned result as `goal` (see the return statement below) — the seam
+  // withLast's withGoalLine reads to prepend the always-on, short "Goal
+  // (inferred): …" line, independent of --narrate entirely. Deliberately the
+  // SAME value the debug trace's own "goal:" line uses (one deduction, two
+  // presentations) — null here (no parse stood at all) means withGoalLine
+  // shows nothing, never a "Goal (inferred): unclear" line.
+  const deduced = deduceGoalFromParsed(envelope?.parsed);
+  note(trace, `goal: ${deduced ?? "unclear — the phrasing didn't resolve to a known query shape"}`);
   // MISS handling. The intent lanes + short-miss are RECOGNIZER-gated on the query
   // text AND only consulted on a would-miss, so a real graph query — a hit, an honest
   // empty with a receipt, a fuzzy repair — is never hijacked. Order: (1) META/SELF
@@ -2698,7 +3395,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 +3641,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 +3718,32 @@ 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;
+  // `goal` (Feature B): the SAME deduced string the debug trace's own "goal:"
+  // line carries (deduced above, right after envelope resolution) — null when
+  // deduceGoalFromParsed found no genuine query shape to bucket on, which is
+  // exactly withGoalLine's own "say nothing" signal. Only runAsk ever sets
+  // this field (plainTurn/runCommand results never carry it), so the always-on
+  // goal line is scoped to real ask-engine turns by construction — a count, a
+  // slash-command or a teach confirmation never grows one.
+  return { answer, logLines, record, focus: newFocus, detail, effectiveQuery, goal: deduced };
 }
 
 /** A non-ask, non-dispatch chat turn (count answer, /stats) — the same
@@ -3119,13 +3887,36 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null })
     const parse = parseAce(line, lex);
     if (!parse || !parse.triples?.length || parse.residue?.length) return null;
     const { assertSentence } = await import("./grammar/assert.mjs");
-    const { normFactTerm } = await import("./memory/core.mjs");
+    const { normFactTerm, appendFact } = await import("./memory/core.mjs");
     const ts = new Date().toISOString();
     const res = await assertSentence(memoryDir, line, {
       lexicon: lex,
       provenance: { source: "chat", sessionId, ts },
     });
     if (!res || !res.ids?.length) return null;
+    // Feature A point 3: a plain universal "every X is a Y" ALSO records the
+    // "every" quantifier on the SAME fact — purely additive (appendFact
+    // upserts by (s,p,o) id, never a duplicate, never changes the confirmation
+    // text below), for the new "how many Xs are Ys" recall lane. Gated on the
+    // literal typed determiner (not on `parse.pattern`, which is "subClassOf"
+    // for the bare-copula variant too) — only "every" reads as a class-level
+    // generalization; a bare/indefinite "X is a Y" is one specific claim and
+    // gets no quantifier. `provenance` is deliberately omitted (appendFact
+    // treats "" as a no-op on the union) so this never grows a redundant tag
+    // alongside the fact's real ace:chat provenance. Best-effort: the base
+    // fact is already durably stored either way, so a failure here (a
+    // relation/cardinality/etc. axiom that happens to start with "every" and
+    // carries no rdfs:subClassOf triple, or any write error) is swallowed.
+    if (/^every\s+/i.test(String(line).trim())) {
+      const triple = res.triples.find((t) => t.predicate === "rdfs:subClassOf");
+      if (triple) {
+        try {
+          await appendFact(memoryDir, {
+            subject: triple.subject, predicate: "rdfs:subClassOf", object: triple.object, quantifier: "every",
+          });
+        } catch { /* best-effort — the base fact is already stored either way */ }
+      }
+    }
     const shown = res.triples
       .map((t) => `${normFactTerm(t.subject)} ${t.predicate} ${normFactTerm(t.object)}`)
       .join("; ");
@@ -3202,8 +3993,19 @@ 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 };
-    return { ...withNarration(finished, trace, fallbackGoal), last: nextLast };
+    // 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 };
+    // FEATURE B: the always-on short "Goal (inferred): …" line — computed from
+    // the SAME PRE-narration `finished` result `nextLast` was just captured
+    // from, so (like narrate) it never contaminates what why/say-more or
+    // repeat-detection compare against. Composes with narrate (below): a
+    // narrated turn gets the short line up top AND the full trace block after.
+    return { ...withNarration(withGoalLine(finished), trace, fallbackGoal), last: nextLast };
   };
 
   // Slash-optional system commands: a bare leading command word ("stats",
@@ -3255,6 +4057,19 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
       return withLast(plainTurn(line, memCount, { via: "count", focus }), "get a count of a memory-store kind");
     }
   }
+  // Feature A point 4: "how many Xs are Ys" — a taught-quantifier RECALL, checked
+  // explicitly ahead of answerCount (see answerQuantifierRecall's own "CRITICAL
+  // ORDERING NOTE" — mirrors answerMemoryCount's precedent just above). Its own
+  // authority gate declines (returns null) for anything answerCount should own,
+  // so ordinary structural counts fall through completely unaffected.
+  if (memoryDir) {
+    const quantifierRecall = await answerQuantifierRecall(memoryDir, line);
+    if (quantifierRecall != null) {
+      note(trace, 'goal: recall a taught quantifier for a class-membership pair ("how many Xs are Ys")');
+      note(trace, "lane: answerQuantifierRecall — matched HOW_MANY_ARE_RE with a subject tmct has facts about; literal recall, never real counting");
+      return withLast(plainTurn(line, quantifierRecall, { via: "fact", focus }), "recall a taught quantifier");
+    }
+  }
   // Aggregate/count questions are answered mechanically off the loaded graph header,
   // BEFORE falling through to the ask engine (focus unchanged — a count names no entity).
   const count = answerCount(graph, line);
@@ -3364,11 +4179,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. */