@polycode-projects/the-mechanical-code-talker 1.0.5 → 1.0.7

package/README.md

@@ -17,7 +17,9 @@ tmct> /callers checkout
 tmct> /exit
 ```
 
-Home page: https://polycode-projects.gitlab.io/the-mechanical-code-talker/
+**[Try it live in your browser →](https://polycode-projects.gitlab.io/the-mechanical-code-talker/)**
+— a real, interactive chat demo running client-side: your browser runs the
+actual query engine against a small example codebase, no server, no install.
 
 ## How it interprets you
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; no codebase index of its own.",

package/src/ask.mjs

@@ -320,6 +320,7 @@ function parseComposite(text, nlp) {
   const w = splitWords(text);
   const lc = w.map((x) => x.toLowerCase());
   return parseExistence(w, lc)
+    || parseQualifierCheck(w, lc)
     || parseNegation(text, nlp, 0)
     || parseForwardNegation(w, lc, nlp)
     || parseTemporal(w, lc, nlp, 0)
@@ -655,6 +656,43 @@ function parseExistence(w, lc) {
                // different (relationship) question; leave it for the parsers below.
 }
 
+/** QUALIFIER-CHECK: "is <term> [a/an] <qualifier> [<kind>]?", "is <term> not
+ *  <qualifier> …" — a single-ENTITY Yes/No property check ("is Task.title
+ *  public", "is it exported", "is that class abstract"), reusing the SAME
+ *  closed QUALIFIERS vocabulary and qualHolds() evaluator the attributive/
+ *  predicative-survey filters already fold over a SET ("public methods",
+ *  "which methods are public") — this is the missing single-entity sibling
+ *  (0.9.15 Tier-1 single-touch playtest: "is it a public attribute?", a
+ *  natural follow-up to a concept-force touch, had no recognizer at all and
+ *  hit the bare grammar wall — even "is Task.title public", a concretely
+ *  NAMED entity with no anaphora involved, walled the same way). Scoped
+ *  tight: a leading "is"/"are", then TERM tokens up to the FIRST recognized
+ *  qualifier word — a leading "the" and a trailing "a"/"an" article around
+ *  the boundary are dropped, and a trailing decorative kind noun ("… public
+ *  ATTRIBUTE") is simply never consumed, never required to agree with the
+ *  resolved entity's real class. Guarded off "is/are THERE …" (parseExistence
+ *  above owns that shape) and off any text with no qualifier word at all, so
+ *  it can never swallow a genuine relationship/existence question. The term
+ *  is resolved at EVAL time (a pronoun binds through the standing contextId,
+ *  exactly like every other object term), never here. */
+function parseQualifierCheck(w, lc) {
+  if (lc[0] !== "is" && lc[0] !== "are") return null;
+  if (lc[1] === "there") return null; // parseExistence's own shape
+  let qualIdx = -1;
+  let negated = false;
+  for (let i = 1; i < lc.length; i += 1) {
+    if (QUALIFIERS[lc[i]]) { qualIdx = i; negated = lc[i - 1] === "not"; break; }
+  }
+  if (qualIdx < 0) return null; // no qualifier word at all → not this shape
+  let termStart = 1;
+  if (lc[termStart] === "the") termStart += 1;
+  let termEnd = negated ? qualIdx - 1 : qualIdx;
+  if (termEnd > termStart && (lc[termEnd - 1] === "a" || lc[termEnd - 1] === "an")) termEnd -= 1;
+  const term = termEnd > termStart ? w.slice(termStart, termEnd).join(" ").trim() : "";
+  if (!term) return { node: "miss", reason: `"is/are <qualifier>" needs a named thing to check first` };
+  return { node: "qualCheck", term, qualifier: lc[qualIdx], negated };
+}
+
 /** Trailing "and that's the whole question" filler an aggregate/list tail can carry
  *  ("how many classes are there", "list functions in total", "which classes exist in
  *  the index") — a count/list over a bare kind is frequently phrased with such a tail,
@@ -825,6 +863,18 @@ function parseSuperlative(w, lc, nlp) {
   for (let i = extIdx; i < lc.length; i += 1) {
     if (EDGE_NOUN_TO_METRIC[lc[i]]) { metric = EDGE_NOUN_TO_METRIC[lc[i]]; metricNoun = lc[i]; break; }
   }
+  // Fallback: a passive-verb-led phrasing puts the participle metric word BEFORE
+  // the extreme, not after ("which function IS CALLED the most" — cf. "which
+  // module is MOST imported", the already-supported order where the participle
+  // trails "most" and the forward scan above already catches it). Scan backward
+  // from just before the extreme, taking the CLOSEST metric word — the natural
+  // reading when one exists at all. Only a fallback (never overrides a forward
+  // hit), so it can't touch any phrasing that already resolves correctly today.
+  if (!metric) {
+    for (let i = extIdx - 1; i >= 0; i -= 1) {
+      if (EDGE_NOUN_TO_METRIC[lc[i]]) { metric = EDGE_NOUN_TO_METRIC[lc[i]]; metricNoun = lc[i]; break; }
+    }
+  }
   const connectivity = lc.includes("connected") || lc.slice(extIdx, extIdx + 2).join(" ") === "most connected"
     || ["largest", "biggest", "smallest"].includes(lc[extIdx]);
   if (!metric) {
@@ -1025,15 +1075,48 @@ function parseRelationalOrQualified(w, lc, nlp, depth) {
     const { blc } = dropLeadCopula(bw, bw.map((x) => x.toLowerCase()));
     return blc.length && blc.every((x) => QUALIFIERS[x]);
   });
+  // A bare "call X and call Y" / "call X but not Y" chain — verb+verb (or
+  // verb+bare-object), no qualifier, no "that" — is ALSO the compositional shape
+  // when branch0 leads with an explicit verb and every OTHER branch is either (a)
+  // an explicit repeat of that SAME mapped verb kind ("call loadStore and call
+  // saveStore" == calls(loadStore) ∩ calls(saveStore)) or (b) a bare object with NO
+  // verb of its own at all ("call saveStore but not loadStore" — "loadStore" alone
+  // inherits "call" via the SAME ellipsis-borrowing buildPredicateAtoms/the atoms
+  // loop below already do for OR-chains like "importing X or Y"; this only widens
+  // the GATE that lets that borrowing fire for and/but-not too). Deliberately
+  // narrower than "any verb+verb and": the compat-guarded bare case ("which classes
+  // extends Base and couples to logging") gives its SECOND branch its own DIFFERENT
+  // explicit verb (coupled-to, not inherits) and so fails case (a) and isn't bare
+  // for case (b) either — it still has no marker and correctly stays on the legacy
+  // ambiguous-parse path, untouched.
+  const sameVerbBranches = predWords.length > 0 ? splitBoolean(predLc, predWords).branches : [];
+  let sameVerbLed = false;
+  if (sameVerbBranches.length > 1) {
+    const firstBlc = sameVerbBranches[0].map((x) => x.toLowerCase());
+    const firstVh = findPhrase(firstBlc, VERB_TO_KIND);
+    if (firstVh && firstVh.start === 0) {
+      sameVerbLed = sameVerbBranches.slice(1).every((bw) => {
+        const blc = bw.map((x) => x.toLowerCase());
+        const vh = findPhrase(blc, VERB_TO_KIND);
+        return vh && vh.start === 0 ? vh.kind === firstVh.kind : !vh;
+      });
+    }
+  }
   // marker gate — the crux of backward-compat: without one of these, this is not a
   // compositional query and we must NOT hijack it from the existing parser.
-  if (!(quals.length || relFlag || membershipLed || gerundLed || boolQualLed)) return null;
+  if (!(quals.length || relFlag || membershipLed || gerundLed || boolQualLed || sameVerbLed)) return null;
 
   // empty predicate → a bare qualified class ("public methods")
   if (!predWords.length) {
     let base = { node: "allOfClass", entityType };
     if (!quals.length) return { node: "miss", reason: "nothing to filter or traverse" };
-    return { node: "qualifier", filters: quals, inner: base };
+    // entityType carried on the qualifier node itself too (not just `inner`) — a
+    // top-level "qualifier" AST has no dedicated evalComposite case, so it falls to
+    // the generic {compositeKind:"set", entityType: ast.entityType||null} catch-all;
+    // without this, a zero-match qualifier query ("public methods of X" with no
+    // public methods) rendered a bare "nothing in the index matches that." with no
+    // entity-kind receipt, same wall-shaped miss as a genuinely unrecognized query.
+    return { node: "qualifier", filters: quals, inner: base, entityType };
   }
 
   const subjPrefix = noun.placeholder ? "what" : `which ${entWord}`;
@@ -1073,7 +1156,9 @@ function parseRelationalOrQualified(w, lc, nlp, depth) {
   } else {
     result = { node: "boolean", entityType, atoms };
   }
-  if (quals.length) result = { node: "qualifier", filters: quals, inner: result };
+  // entityType carried on the qualifier wrapper too — see the identical comment on
+  // the empty-predicate qualifier node above; same catch-all-miss-receipt fix.
+  if (quals.length) result = { node: "qualifier", filters: quals, inner: result, entityType };
   return result;
 }
 
@@ -1499,7 +1584,8 @@ function evalBoolean(graph, ast, opts) {
 function evalAnaphora(graph, ast, opts) {
   const prev = opts && opts.prev;
   if (!Array.isArray(prev) || !prev.length) return { compositeMiss: true, reason: "no-prev", matches: [] };
-  let items = prev.map((id) => graph.byId.get(id)).filter(Boolean);
+  const baseItems = prev.map((id) => graph.byId.get(id)).filter(Boolean);
+  let items = baseItems;
   const f = ast.filter;
   if (f && f.type === "qual") {
     items = items.filter((ind) => f.filters.every((q) => qualHolds(graph, ind, QUALIFIERS[q])));
@@ -1516,7 +1602,14 @@ function evalAnaphora(graph, ast, opts) {
     }
   }
   // a count over a prior set names the entity kind when the survivors share a class.
-  const common = items.length && items.every((x) => x.class === items[0].class) ? items[0].class : null;
+  // When the filter narrows a real prior set down to ZERO, fall back to the PRIOR
+  // set's own class (still shared, pre-filter) so the honest-empty render still
+  // names what was checked ("nothing in the index matches that (methods)."
+  // instead of a bare, kind-less "nothing in the index matches that.") — the
+  // filter genuinely found no survivors, but the entity kind it filtered is not
+  // itself unknown, so the miss shouldn't read as if it were.
+  const sameClass = (list) => (list.length && list.every((x) => x.class === list[0].class) ? list[0].class : null);
+  const common = items.length ? sameClass(items) : sameClass(baseItems);
   if (ast.mode === "count") return { compositeKind: "count", count: items.length, entityType: common, matches: [] };
   return { compositeKind: "set", matches: items, entityType: common };
 }
@@ -1598,11 +1691,29 @@ function evalExists(graph, ast) {
   return { compositeKind: "exists", entityType, term: null, scopeModule, scopeMatch, matches: pool };
 }
 
+/** QUALIFIER-CHECK eval — resolve the term (a context pronoun binds through
+ *  contextId, exactly like resolveTermOrContext's every other caller), then
+ *  read the SAME qualHolds() predicate the set-filter path already uses.
+ *  `holds` here means "the STATEMENT AS ASKED is true" (negation already
+ *  folded in), so the renderer can answer Yes/No directly off it without
+ *  re-deriving the negation. An unresolved term is an honest miss, never a
+ *  guess — no different from any other named-object lookup. */
+function evalQualCheck(graph, ast, opts) {
+  const { term, qualifier, negated } = ast;
+  const r = resolveTermOrContext(graph, term, opts.contextId);
+  if (r.unresolvedPronoun) return { compositeKind: "qualCheck", qualCheckMiss: "pronoun", term, matches: [] };
+  if (!r.match) return { compositeKind: "qualCheck", qualCheckMiss: "unresolved", term, matches: [] };
+  const rawHolds = qualHolds(graph, r.match, QUALIFIERS[qualifier]);
+  const holds = negated ? !rawHolds : rawHolds;
+  return { compositeKind: "qualCheck", subject: r.match, qualifier, negated, holds, matches: [r.match] };
+}
+
 /** Compile any compositional AST to a result object traverse() returns for the
  *  simple path — {matches, …} plus compositeKind/compositeMiss flags render() reads. */
 export function evalComposite(graph, ast, opts = {}) {
   if (ast.node === "miss") return { compositeMiss: true, reason: ast.reason || null, matches: [] };
   if (ast.node === "exists") return evalExists(graph, ast);
+  if (ast.node === "qualCheck") return evalQualCheck(graph, ast, opts);
   if (ast.node === "count") return { compositeKind: "count", count: evalSet(graph, ast.base, opts).length, entityType: ast.entityType, matches: [] };
   if (ast.node === "list") return { compositeKind: "list", matches: evalSet(graph, ast.base, opts), entityType: ast.entityType, scoped: ast.scoped };
   if (ast.node === "superlative") return evalSuperlative(graph, ast);
@@ -1676,6 +1787,27 @@ function renderComposite(parsed, result) {
     }
     return { content: `Yes — ${compositeList(result.matches)}${scopeSuffix}.`, miss: false, ambiguous: false, matches: result.matches };
   }
+  // qualCheck: "is <term> [a/an] <qualifier> […]" — the single-entity sibling of
+  // "is there a/an <kind> …" above: a direct Yes/No over one already-named/-
+  // focused individual, never a set listing. `result.holds` already has the
+  // negation folded in (evalQualCheck), so the renderer states the actual truth
+  // plainly — "No — X is tested." for "is X not tested" when X IS tested, never
+  // an echo of the (now-false) question's own wording.
+  if (result.compositeKind === "qualCheck") {
+    if (result.qualCheckMiss === "pronoun") {
+      return { content: `"${result.term}" needs a selected node to refer to — click a node first, or name it directly.`, miss: true, ambiguous: false };
+    }
+    if (result.qualCheckMiss === "unresolved") {
+      return { content: `couldn't find "${result.term}" in the index to check.`, miss: true, ambiguous: false };
+    }
+    const label = result.subject.label;
+    const truePhrase = result.negated ? `not ${result.qualifier}` : result.qualifier;
+    const falsePhrase = result.negated ? result.qualifier : `not ${result.qualifier}`;
+    return {
+      content: `${result.holds ? "Yes" : "No"} — ${label} is ${result.holds ? truePhrase : falsePhrase}.`,
+      miss: false, ambiguous: false, matches: result.matches,
+    };
+  }
   if (result.compositeKind === "count") {
     const noun = result.entityType ? nounFor(result.entityType, result.count) : (result.count === 1 ? "result" : "results");
     return { content: `${result.count} ${noun}.`, miss: false, ambiguous: false, matches: [] };
@@ -2994,10 +3126,22 @@ export function relaxParse(graph, query, { nlp = undefined, contextId = null, pr
   // own as vocabulary/scaffolding? Guards against a relaxation that drops the actual
   // asked term and lets a bare marker slide into its place ("where is [X] defined" →
   // "where is defined", "defined" is a WHERE_MARKER, never the thing being located).
-  const hasRealTerm = (s) => splitWords(String(s || "")).some((w) => {
-    const lc = w.toLowerCase();
-    return !CONTENT_VOCAB.has(lc) && !STRUCTURAL_WORDS.has(lc);
-  });
+  // A bare CONTEXT PRONOUN ("it"/"this"/"that"/"here"/…) is the one exception: it IS
+  // the real, deliberate object here — it resolves through contextId, not through
+  // vocabulary the grammar "already owns" as scaffolding — so it must count as a real
+  // term rather than being mistaken for a dropped-into-place marker. Without this, a
+  // relaxed candidate whose object survived layer 2 as a lone pronoun ("what else is
+  // in that class" → drop "class"/"else" → "what does that contain") was rejected as
+  // if it named nothing at all, even though the pronoun resolves to a real, answerable
+  // focus (0.9.15 Tier-1 single-touch playtest).
+  const hasRealTerm = (s) => {
+    const whole = String(s || "").trim().toLowerCase();
+    if (CONTEXT_PRONOUNS.includes(whole)) return true;
+    return splitWords(whole).some((w) => {
+      const lc = w.toLowerCase();
+      return !CONTENT_VOCAB.has(lc) && !STRUCTURAL_WORDS.has(lc);
+    });
+  };
   // Accept a relaxed attempt ONLY if it is a genuinely answerable parse (terms resolve)
   // AND it renders a REAL positive answer — never another empty/miss (relaxation earns a
   // win only by turning a miss into an answer, never a differently-worded miss) — and

package/src/chat.mjs

@@ -1266,6 +1266,12 @@ const HAS_PROPERTY_PREDICATE = "mgx:hasProperty";
 // "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";
+// Bug 3 (2026-07-09): the SAME "has a" predicate ConceptNet's own /r/HasA
+// facts already use (FACT_PREDICATE_PHRASES, conceptnet-map.toml) — named
+// here too so generalVerbTeach's "has"/"have" special case (below) stays
+// obviously in that same family, interoperable with corpus HasA data on the
+// read side, rather than minting a redundant mgx:has.
+const HAS_A_PREDICATE = "mgx:hasA";
 
 /** "<Name> owns/maintains <X>" — the ownership teach declarative. <Name> is one
  *  or two name tokens, <X> one code-ish token (a path, a file, a symbol). The
@@ -1299,7 +1305,7 @@ async function teachFact(memoryDir, sessionId, { subject, predicate, object, qua
       provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
       ...(quantifier ? { quantifier } : {}),
     });
-    const phrase = FACT_PREDICATE_PHRASES[predicate] || predicate;
+    const phrase = predicatePhrase(predicate);
     return { text: `noted — remembered: ${s} ${phrase} ${o}`, via: "assert", miss: false };
   } catch {
     return null;
@@ -1398,6 +1404,111 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   return null; // Y unknown too — decline honestly, never guess
 }
 
+// ---- BUG 3 (2026-07-09, operator-authorized generalizing — "I don't know
+// where that ban came from, overturn it. build it."): general verb-to-
+// predicate teaching. "remember tony has a hat" / "remember margo eats ribs"
+// used to fall straight through teachLane returning null (not even this
+// lane's own honest miss text) because the ONLY verbs the lane recognized at
+// all were is/are (class-membership/property) and owns/maintains
+// (ownership) — a sentence with any OTHER verb never matched a single
+// recognizer, and fell to the STRUCTURAL code-graph grammar, which of course
+// can't resolve an arbitrary proper noun as a code entity (confusing,
+// wrong-context miss text, and sometimes a confidently WRONG "Goal
+// (inferred)" line — runAsk's own teach-lane goal deduction fixes that half).
+//
+// RECOGNITION stays exactly as CLOSED as every other frame in this lane:
+// wrapper-REQUIRED (teachLane only ever calls generalVerbTeach on `wrapped`,
+// i.e. only inside an already "remember/note/…"-triggered payload — a bare
+// "tony has a hat" is never silently reified, same discipline
+// TEACH_PROPERTY_RE already uses), and only a well-formed <subject> <verb>
+// <object> triple matches AT ALL (point 6 — a missing/unparseable object
+// still declines honestly, never a guess). What's generalized is ONLY the
+// PREDICATE a recognized shape maps to, never what counts as a recognized
+// shape — the same "recognition closed, mapping generalized" split the
+// operator explicitly authorized over this dispatch's default "prefer
+// templates" guidance. ----
+
+/** <subject> (ONE bare word — a name, "tony"/"margo") <verb> (one lowercase
+ *  word) <object> (the rest). Deliberately bounded to a SINGLE-TOKEN subject
+ *  with no leading determiner — not the lazy/greedy multi-word subject the
+ *  is/are frames elsewhere in this lane tolerate. Reasoning (found live while
+ *  building this): without real verb-position knowledge, a positional regex
+ *  over an ARBITRARY-length subject is genuinely ambiguous — "every
+ *  controller is a handler" would just as happily (mis)parse as
+ *  subject="every", verb="controller", object="is a handler" as it would the
+ *  intended reading. Bounding the subject to one bare word removes that
+ *  ambiguity for exactly the shape this mechanism targets (a name-like
+ *  subject, per the operator's own examples); a determiner/quantifier-led or
+ *  multi-word subject simply doesn't match here and honestly declines
+ *  (point 6) rather than risk a wrong split — the is/are-specific frames
+ *  elsewhere in this lane already own that broader territory. */
+const GENERAL_VERB_TEACH_RE = /^([\w'-]+)\s+([a-z]+)\s+(.+?)[.!?]*$/i;
+/** Determiners/quantifiers that make the FIRST token an article, not a real
+ *  bare-name subject ("every controller…", "the cache…") — GENERAL_VERB_TEACH_RE
+ *  would otherwise happily bind them as a 1-token subject and misread the
+ *  REAL subject's second word as the verb. Declining here hands the sentence
+ *  back to the is/are-specific frames above/below (their own territory) or an
+ *  honest miss — never a guessed split. */
+const GENERAL_VERB_DETERMINER_RE = /^(?:every|each|all|some|a|an|the|your|my|our|their|his|her|its)$/i;
+/** Verbs owned by an earlier, more specific recognizer in this lane — is/are
+ *  (class-membership/property, above) and owns/maintains (ownership, above).
+ *  generalVerbTeach declines outright on these so it can never race a more
+ *  specific frame for the same sentence; a genuine miss on one of THESE verbs
+ *  stays that frame's own honest miss, never silently reinterpreted here. */
+const GENERAL_VERB_EXCLUDE_RE = /^(?:is|are|am|owns|maintains)$/i;
+/** Whole-payload safety net (defense in depth alongside the single-token
+ *  subject bound above): if "is"/"are"/"am"/"owns"/"maintains" appears
+ *  ANYWHERE in the sentence — not just at the guessed verb position — this
+ *  is territory another frame in this lane already owns (or will, in the
+ *  is/are payload block right after this one runs), so generalVerbTeach
+ *  stands down entirely rather than risk a positional misread of a longer
+ *  copula/ownership sentence it was never meant to parse. */
+const GENERAL_VERB_ANYWHERE_EXCLUDE_RE = /\b(?:is|are|am|owns|maintains)\b/i;
+
+/** The predicate a general-verb teach payload's VERB maps to. "has"/"have"
+ *  special-cases onto the EXISTING mgx:hasA predicate (point 2) — the same
+ *  one ConceptNet's own /r/HasA facts already use (FACT_PREDICATE_PHRASES),
+ *  so a taught "X has a Y" fact reads back interoperably with corpus HasA
+ *  data, rather than minting a redundant mgx:has. Any OTHER verb mints
+ *  mgx:<lemma> (point 3a) — proseLemma, the wink-nlp lemmatiser this
+ *  codebase already loads elsewhere (prose-nlp.mjs), canonicalizes "eats"/
+ *  "ate"/"eating" alike onto the same mgx:eat predicate; when the optional
+ *  wink model isn't installed, proseLemma degrades to null (its own
+ *  documented contract) and this falls back to the verb AS TYPED — still a
+ *  perfectly storable/retrievable predicate, just not cross-inflection
+ *  canonicalized. Never a hand-curated per-verb table entry required. */
+async function generalVerbPredicate(verb) {
+  const v = String(verb || "").toLowerCase();
+  if (v === "has" || v === "have") return HAS_A_PREDICATE;
+  try {
+    const { proseLemma } = await import("./prose-nlp.mjs");
+    const lemma = proseLemma();
+    return `mgx:${lemma ? lemma(v) : v}`;
+  } catch {
+    return `mgx:${v}`;
+  }
+}
+
+/** Recognize + resolve a general-verb teach payload into {subject, predicate,
+ *  object}, or null when it doesn't fit the shape / names an excluded verb /
+ *  is missing a real subject or object (point 6 — an honest decline, never a
+ *  guess). Pure recognition + predicate mapping; the caller (teachLane) does
+ *  the actual write via the shared teachFact. */
+async function generalVerbTeach(payload) {
+  const p = String(payload || "").trim();
+  if (GENERAL_VERB_ANYWHERE_EXCLUDE_RE.test(p)) return null; // another frame's territory — stand down
+  const m = p.match(GENERAL_VERB_TEACH_RE);
+  if (!m) return null;
+  const [, subjectRaw, verbRaw, objectRaw] = m;
+  const verb = verbRaw.toLowerCase();
+  if (GENERAL_VERB_EXCLUDE_RE.test(verb)) return null; // owned by a more specific frame above
+  if (GENERAL_VERB_DETERMINER_RE.test(subjectRaw)) return null; // not a bare-name subject
+  const subject = subjectRaw.trim();
+  const object = objectRaw.replace(/^an?\s+/i, "").trim();
+  if (!subject || !object) return null; // no well-formed triple — honest decline (point 6)
+  const predicate = await generalVerbPredicate(verb);
+  return { subject, predicate, object };
+}
 
 /** 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
@@ -1448,8 +1559,19 @@ function teachSuggestion(payload) {
  *  double as legitimate demonstrative entity references elsewhere in this
  *  file (DESCRIBE_PRONOUN_RE, NEGATION_PRONOUN_RE et al.), and a claim about
  *  a demonstrated entity ("that is a bug", pointing at something real) is a
- *  much closer call than "every you is a womble" — not this bug's territory. */
-const TEACH_PRONOUN_RE = /^(?:every\s+|each\s+|all\s+|some\s+|a few\s+|a\s+|an\s+)?(you|i|it|they|he|she|we)\s+(?:is|are|am)\b/i;
+ *  much closer call than "every you is a womble" — not this bug's territory.
+ *
+ *  WIDENED (Bug 3, 2026-07-09): the verb group used to be the closed
+ *  is/are/am copula set — correct while pronoun subjects could only ever
+ *  reach a class-membership/property claim, but Bug 3's generalVerbTeach
+ *  (below) opens a SECOND way a pronoun subject can reach the store, via ANY
+ *  verb ("remember you has a hat", "remember he eats ribs"). A pronoun is
+ *  just as invalid a fact subject under a general verb as it is under "is" —
+ *  this is a grammatical category error regardless of the verb — so the verb
+ *  slot now matches ANY word, not just the copula three, keeping the guard
+ *  ahead of every teach recognizer (copula AND general-verb alike) the same
+ *  way it already stood ahead of teachSuggestion/unknownSubjectFallback. */
+const TEACH_PRONOUN_RE = /^(?:every\s+|each\s+|all\s+|some\s+|a few\s+|a\s+|an\s+)?(you|i|it|they|he|she|we)\s+\S+/i;
 
 async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   const rawInput = String(query).trim();
@@ -1522,6 +1644,24 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
     }
   }
 
+  // GENERAL VERB-TO-PREDICATE TEACH (Bug 3) — "remember <Subject> <verb>
+  // <Object>" where <verb> is neither is/are (handled below via the ACE/
+  // unknown-subject/property paths) nor owns/maintains (handled above).
+  // Wrapper-REQUIRED (`wrapped`, not `raw`) — see generalVerbTeach's own
+  // docblock for why this keeps recognition exactly as closed as every other
+  // frame in this lane. Tried before the is/are `payload` block below so a
+  // non-copula verb never falls through this function returning null with no
+  // miss text at all (the ORIGINAL bug: "remember tony has a hat" never even
+  // reached this lane's own honest-miss cascade, landing on the structural
+  // grammar's wrong-context wall instead).
+  if (wrapped && memoryDir && !QUESTION_LEAD_RE.test(wrapped)) {
+    const gv = await generalVerbTeach(wrapped);
+    if (gv) {
+      const stored = await teachFact(memoryDir, sessionId, gv);
+      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;
@@ -2241,7 +2381,33 @@ const FACT_PREDICATE_PHRASES = {
   "mgx:hasPrerequisite": "requires",
   "mgx:ownedBy": "is owned by", // the teach lane's ownership frame ("Priya owns tasks.mjs")
 };
-const factPhrase = (f) => `${f.subject} ${FACT_PREDICATE_PHRASES[f.predicate] || f.predicate} ${f.object}`;
+
+/** Bug 3 (2026-07-09) point 3b: the MECHANICAL fallback for a predicate this
+ *  table has no curated entry for — specifically generalVerbTeach's minted
+ *  "mgx:<lemma>" predicates ("mgx:eat", "mgx:drive", …), which by design have
+ *  no per-verb table row (that would be the anti-pattern the operator's
+ *  dispatch explicitly called out to avoid). Reconstructs the naive third-
+ *  person-singular surface form so "margo mgx:eat ribs" still renders as the
+ *  natural "margo eats ribs" — the mechanical INVERSE of singularizeSurface's
+ *  own naive -s/-es/-ies fold used elsewhere in this file, same accepted-
+ *  limitation trade (no real morphology; a handful of doubly-irregular verbs
+ *  render slightly off but never wrong-MEANING). "has"/"have" never reach
+ *  this fallback — generalVerbPredicate special-cases them onto the CURATED
+ *  mgx:hasA entry above before a predicate is ever minted. Any OTHER unknown
+ *  predicate (not the "mgx:<lemma>" shape — e.g. a stray/foreign CURIE) still
+ *  renders verbatim, unchanged from before this fix. */
+function thirdPersonSingularSurface(lemma) {
+  const w = String(lemma || "");
+  if (/[a-z]y$/i.test(w) && !/[aeiou]y$/i.test(w)) return `${w.slice(0, -1)}ies`;
+  if (/(?:s|x|z|ch|sh|o)$/i.test(w)) return `${w}es`;
+  return `${w}s`;
+}
+function predicatePhrase(predicate) {
+  if (FACT_PREDICATE_PHRASES[predicate]) return FACT_PREDICATE_PHRASES[predicate];
+  const m = /^mgx:([a-z]+)$/i.exec(String(predicate || ""));
+  return m ? thirdPersonSingularSurface(m[1]) : predicate;
+}
+const factPhrase = (f) => `${f.subject} ${predicatePhrase(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
@@ -2458,10 +2624,12 @@ async function factAnswer(memoryDir, query, envelope, miss) {
   // alongside the schema-docs answer) and misses (facts answer alone) alike.
   // When the engine produced NO parse at all (the empty-bootstrap graph
   // short-circuits before parsing), the meta FORM is recognized directly on a
-  // miss — same required-article discipline as the grammar's own T5 template.
+  // miss — via BARE_WHATIS_RE (chat.mjs's own fact-lookup discipline, article
+  // OPTIONAL — see that regex's docblock for why this is safe to loosen here
+  // even though the structural grammar's T5 keeps the article mandatory).
   let metaTerm = envelope?.parsed?.shape === "meta" ? envelope.parsed.object : null;
   if (!metaTerm && miss && !envelope?.parsed) {
-    const m = q.match(/^what\s+(?:is|are)\s+an?\s+(.+?)[?.!\s]*$/i)
+    const m = q.match(BARE_WHATIS_RE)
       || q.match(/^what\s+(?:does|do)\s+(.+?)\s+means?[?.!\s]*$/i);
     if (m) metaTerm = m[1];
   }
@@ -2527,6 +2695,83 @@ async function factAnswer(memoryDir, query, envelope, miss) {
   return null;
 }
 
+// ---- BUG 1 fix (2026-07-09): "what else is X" repeated the SAME primary
+// definition sentence verbatim, byte-identical to a plain "what is X" turn
+// right before it. Root cause: "what else is a function" is NOT itself a
+// recognized shape anywhere in this file — ask()'s own relaxation cascade
+// (relaxParse, ask.mjs: NOISE-STRIP then DROP-UNMATCHED) quietly treats
+// "else" as an unmatched leftover token once the anchored grammar misses the
+// sentence as typed, drops it, and re-parses the survivor as the ORDINARY
+// "what is a function" meta shape — a real, non-miss answer, so relaxParse
+// happily accepts it. By the time curatedDefinitionAnswer/factAnswer see the
+// query, "else" is already gone and there is nothing left to distinguish a
+// follow-up asking for MORE from the original question. whatElseAnswer is
+// recognized FIRST, off the RAW query text (never the relaxed envelope), so
+// it always gets first look regardless of what the ask engine's own parse
+// collapsed the sentence to. ----
+
+/** "what else is/are X" / "what else about X" / "what else do you know about
+ *  X" — the follow-up shape asking for information BEYOND whatever the
+ *  primary answer already said. Two separate anchors (not one alternation)
+ *  because the "is/are" copula form and the "about" form take the article
+ *  differently ("what else is a function" vs "what else about the cache").
+ *  The negative lookahead on the "is/are" form excludes "what else is
+ *  in/inside X" — that's a DIFFERENT, already-working feature (normalize.mjs
+ *  PHRASING_FRAMES rewrites it to "what does X contain", a members-of-class
+ *  query, tested by chatflow-tier1-single-touch.test.mjs); without this
+ *  exclusion this lane's own raw-text-first priority (it runs BEFORE ask()'s
+ *  pipeline even gets a look) would wrongly swallow that idiom as a
+ *  vocabulary-term lookup for the literal term "in X". */
+const WHAT_ELSE_IS_RE = /^what\s+else\s+(?:is|are)\s+(?!in\b|inside\b)(?:an?\s+)?(.+?)[?.!\s]*$/i;
+const WHAT_ELSE_ABOUT_RE = /^what\s+else\s+(?:do\s+you\s+know\s+)?about\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i;
+
+/** "what else is X" — surface remembered facts about X BEYOND the primary
+ *  curated (corpus/seon) prose definition, which is itself never a Facts row
+ *  (it comes from a separate prose file, seonDefinitions() — see
+ *  curatedDefinitionAnswer) — so every subject-side fact this returns is
+ *  genuinely additional information, never a repeat of the definition
+ *  sentence. Reuses factAnswer's own subject-scan machinery (memoryFacts +
+ *  factTermVariants + renderFactLine + the SAME FACT_ANSWER_CAP/'more'-paging
+ *  convention as factAnswer/factReadBack), just filtered/framed differently.
+ *
+ *  Honest "nothing more" fallback (never a spurious repeat) in TWO cases: (a)
+ *  the term carries no facts at all — there is nothing to add beyond the
+ *  definition; (b) every fact line this would show ALREADY appears verbatim
+ *  in the immediately-preceding turn's answer (`last.answer`) — meaning the
+ *  primary answer was itself an exhaustive fact listing (via:"fact", not a
+ *  curated prose definition), so "what else" truly has nothing new to say.
+ *  That second check reuses this codebase's own established repeat-detection
+ *  discipline (comparing rendered lines against `last.answer` bytes — see
+ *  ORIENTATION_REPEAT_ONELINER/WALL_REPEAT_ONELINER for the same pattern). */
+async function whatElseAnswer(memoryDir, query, last) {
+  if (!memoryDir) return null;
+  const q = String(query).trim();
+  const m = q.match(WHAT_ELSE_IS_RE) || q.match(WHAT_ELSE_ABOUT_RE);
+  if (!m) return null;
+  const term = m[1].trim();
+  if (!term) return null;
+  let normFactTerm;
+  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  const variants = factTermVariants(normFactTerm, term);
+  const hits = (await memoryFacts(memoryDir)).filter((f) => variants.has(f.subject));
+  const nothingMore = {
+    text: `That's everything I know about "${term}" — /memory to see the full picture.`,
+    replace: true,
+  };
+  if (!hits.length) return nothingMore;
+  const lines = hits.map(renderFactLine);
+  const prevAnswer = String(last?.answer || "");
+  if (lines.every((l) => prevAnswer.includes(l))) return nothingMore;
+  const shown = lines.slice(0, FACT_ANSWER_CAP);
+  const rest = lines.slice(FACT_ANSWER_CAP);
+  const extra = rest.length ? `\n…and ${rest.length} more — say 'more' to see them.` : "";
+  return {
+    text: `Beyond that, here's what else I know about "${term}":\n${shown.join("\n")}${extra}`,
+    replace: true,
+    ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}),
+  };
+}
+
 /** Ontology plan tracks (a)+(b) (PLAN_ontology-hierarchies.md §3): a LAST-
  *  RESORT query-time synonym expansion for a "what is a X"-shaped term with NO
  *  direct facts. Deliberately run where the caller runs it (runAsk, after
@@ -3058,13 +3303,34 @@ function relationDefinitions() {
   return seonRelsPromise;
 }
 
-/** The meta term a "what is a X" / "what does X mean" / "define X" question asks
- *  about — from the parse when present, else recognized directly (same required-
- *  article discipline as the grammar's T5). Null when the line isn't such a form. */
+/** BUG 2 fix (2026-07-09): "what is a/an <term>" with the article made OPTIONAL,
+ *  for the FACT-LOOKUP path only (metaTermOf/factAnswer's own bare-form fallback)
+ *  — NOT grammar.mjs's structural T5 template, which keeps its article MANDATORY
+ *  on purpose (a bare "what is <anything>" would also swallow "what is the
+ *  meaning of this codebase", an existing, deliberately honest grammar-miss
+ *  regression — test/ask.test.mjs pins it null; see T5's own docblock). That
+ *  collision risk is a STRUCTURAL-PARSE concern (T5's tail becomes the literal
+ *  graph-query object); it doesn't apply here: this regex only extracts a
+ *  SUBJECT STRING to look up against the memory Facts store / curated lexicon —
+ *  a miss (no fact, no lexicon entry) is silently absorbed by the caller and
+ *  falls through to the ordinary honest-miss cascade, exactly like today's
+ *  mandatory-article miss does. Root cause this fixes: "what is john" (no
+ *  article) never matched the old mandatory-article regex at all, so a freshly
+ *  taught "john rdfs:subClassOf function" fact was invisible to "what is john"
+ *  even though "what is a john" (or "what is john used for") would have found
+ *  it — the fact-lookup path is a low-collision subject lookup, not a structural
+ *  parse, so loosening it here is safe. */
+const BARE_WHATIS_RE = /^what\s+(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
+
+/** The meta term a "what is a X" / "what is X" / "what does X mean" / "define X"
+ *  question asks about — from the parse when present, else recognized directly
+ *  via BARE_WHATIS_RE (article optional — see its own docblock for why that's
+ *  safe here even though the grammar's own T5 keeps the article mandatory).
+ *  Null when the line isn't such a form. */
 function metaTermOf(query, envelope) {
   if (envelope?.parsed?.shape === "meta" && envelope.parsed.object) return envelope.parsed.object;
   const q = String(query).trim();
-  const m = q.match(/^what\s+(?:is|are)\s+an?\s+(.+?)[?.!\s]*$/i)
+  const m = q.match(BARE_WHATIS_RE)
     || q.match(/^what\s+(?:does|do)\s+(?:an?\s+)?(.+?)\s+means?[?.!\s]*$/i)
     || q.match(/^define\s+(?:an?\s+)?(.+?)[?.!\s]*$/i);
   return m ? m[1].trim() : null;
@@ -3603,6 +3869,27 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // facts/recall (a fact EXTENDS a non-miss schema hit too — NOT miss-gated),
   // (4) TEACH lane (would-miss), (5) the short tailored miss (would-miss).
   let handled = false;
+  // (0) BUG 1 fix (2026-07-09): "what else is X" — recognized off the RAW
+  // query text, before every other lane below (all of which read `envelope`,
+  // already relaxed/reparsed by ask()'s own noise-strip cascade — "else" is
+  // exactly the kind of unmatched token that cascade silently drops, which is
+  // why a plain factAnswer/curatedDefinitionAnswer lookup used to answer
+  // "what else is X" with the byte-identical primary definition, as if
+  // repeating it were new information). via is set to a value NONE of the
+  // downstream `via === "composed"/"fact"/"corpus/seon"` gates match, so a
+  // hit here is final — curatedDefinitionAnswer/conceptForceAnswer never get
+  // a chance to re-answer with the same primary definition afterward.
+  if (memoryDir) {
+    const whatElse = await whatElseAnswer(memoryDir, query, last);
+    if (whatElse) {
+      answer = whatElse.text; via = "fact:what-else"; recordMiss = false; handled = true;
+      if (whatElse.pending) factPending = whatElse.pending;
+      deduced = "surface additional remembered facts beyond the primary definition";
+      note(trace, "lane: (0) WHAT ELSE — \"what else is/about X\" recognized off the raw query, before the relaxation cascade could quietly drop \"else\" and reduce it to a plain \"what is X\"");
+      note(trace, "source: .tmct/memory Facts (see /memory for provenance per line)");
+      note(trace, `goal: ${deduced} (revised — the raw \"what else\" phrasing was recognized directly, not the relaxed/reparsed envelope)`);
+    }
+  }
   // (1) #2 META/SELF: bare self/session questions ("what do you know", "what is this
   // codebase", "how do i start") → a summary / orientation, answered before the
   // fact-dump readers so "what do you know" gets a summary, not raw facts.
@@ -3702,7 +3989,37 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       } catch { /* leave false — the ordinary path decides */ }
     }
   }
-  if (!handled && miss && !envelope?.parsed && isConversational(query) && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus) {
+  const isConversationalCandidate = !handled && miss && !envelope?.parsed && isConversational(query) && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus;
+  // BUG 2 fix (2026-07-09): "what is X" with NO article ("what is john") is BOTH
+  // conversational-shaped (≤3 words, no code-ish token — isConversational() would
+  // claim it) AND a legitimate bare meta/fact-lookup form (BARE_WHATIS_RE —
+  // metaTermOf's own docblock explains why the article is safe to make optional on
+  // this fact-lookup path specifically). Root cause: grammar.mjs's T5 template
+  // requires the article, so envelope.parsed stays null for the bare form — which
+  // is exactly isConversationalCandidate's own `!envelope?.parsed` gate — so
+  // isConversational used to win the race unconditionally, and a freshly taught
+  // "john is a function" fact became invisible the moment its own subject was
+  // asked back about bare ("what is john" fell to the generic capability-
+  // orientation card, byte-identical to asking about a term tmct had never heard
+  // of). Diverts ONLY when a REAL fact actually resolves for the bare term —
+  // never a speculative reroute: a bare "what is up"/"what is wrong" with nothing
+  // behind it falls straight through to the SAME orientation card as before,
+  // exactly like every other isConversationalCandidate exemption above (each one
+  // guarantees a real answer before it defers, never stranding the turn on a
+  // worse outcome — see isStaccatoPronounNoFocus's own docblock for the same
+  // discipline).
+  let bareMetaHit = null;
+  if (isConversationalCandidate && memoryDir && BARE_WHATIS_RE.test(String(query).trim())) {
+    bareMetaHit = (await factAnswer(memoryDir, query, envelope, miss))
+      ?? (await factReadBack(memoryDir, query, envelope, miss, graph));
+  }
+  if (bareMetaHit) {
+    answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
+    via = "fact"; recordMiss = false; handled = true;
+    if (bareMetaHit.pending) factPending = bareMetaHit.pending;
+    note(trace, "lane: (2b) BARE META FACT — \"what is X\" (no article) resolved to a remembered fact before the conversational catch-all could claim it");
+    note(trace, "source: .tmct/memory Facts (see /memory for provenance per line)");
+  } else if (isConversationalCandidate) {
     // A conversational miss (a greeting, "what can you do", a very short non-code
     // 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
@@ -3861,7 +4178,21 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     if (taught) {
       answer = taught.text; via = taught.via; recordMiss = taught.miss;
       note(trace, `lane: (4) TEACH — TEACH_RE/OWNS_TEACH_RE/BARE_DECLARATIVE_RE matched, ${taught.miss ? "but the payload could not be stored" : "reified into .tmct/memory"}`);
-      note(trace, "goal: teach/remember a new fact");
+      // Goal-line fix (Bug 3 point 4, 2026-07-09): `deduced` was computed WAY
+      // above, straight off envelope.parsed alone (deduceGoalFromParsed) —
+      // the structural grammar has no business parsing a teach-shaped
+      // sentence at all ("remember tony has a hat" isn't a code-graph
+      // question), so whatever it landed on there was either confidently
+      // WRONG (a stray structural template matched part of the sentence and
+      // deduced an unrelated GOAL_BY_KIND entry, e.g. "locate what a
+      // module/class defines") or silently absent (no parse stood). Every
+      // successfully-RECOGNIZED teach attempt (`taught` stood — whether it
+      // went on to STORE or to its own honest teach-miss text) gets the SAME
+      // honest, consistent goal line here instead — the same "revise off the
+      // LANE that actually answered, not the raw structural parse"
+      // discipline the relation-force fix above already uses.
+      deduced = "teach/remember a new fact";
+      note(trace, `goal: ${deduced} (revised — the teach lane recognized this shape where the raw structural parse never should have)`);
     }
   }
   // (4b) #4 AUTHOR lane (0.8.2 WS4) — "who is <Name>", "what did <Name> touch",

package/src/interpret/normalize.mjs

@@ -44,6 +44,33 @@ const correctionRe = (table) => new RegExp(
 const MISSPELLING_RE = correctionRe(MISSPELLINGS);
 const WRONG_WORD_RE = correctionRe(WRONG_WORDS);
 
+/** "that class"/"this module"/"that function" (a context pronoun immediately
+ *  followed by the SINGULAR kind noun it's already standing in for) -> the bare
+ *  pronoun alone (0.9.15 Tier-1 single-touch playtest). "which class contains
+ *  Task.complete" answers by NAMING the class ("… there is Task"); a curious
+ *  user's very next turn naturally says "what is in that class", not the bare
+ *  "what is in that" the grammar already understands. Left unstripped, the two
+ *  parse strategies disagreed on the SPAN (grammar kept "that class" as one
+ *  literal 2-word object term; keyword-spot split off "class" as an entityType
+ *  keyword, leaving bare "that" as the object) — same PARSE, different shape,
+ *  so merge.mjs's honest {ambiguousParse} tie fired even though a human reads
+ *  this as one unambiguous sentence. Folding the kind noun away BEFORE either
+ *  strategy runs leaves exactly one reading: CONTEXT_PRONOUNS' own existing
+ *  focus-resolution (ask.mjs's resolveTermOrContext) then takes it from there,
+ *  unchanged — this frame only removes the strategy disagreement, it does not
+ *  touch how the pronoun itself resolves. Singular kind nouns only ("that
+ *  classes" isn't grammatical, so plurals are never a real anaphora and are
+ *  left alone); "one" is excluded ("that one" is already its own literal
+ *  CONTEXT_PRONOUNS entry). */
+const KIND_NOUN_ANAPHORA_RE = /\b(this|that)\s+(class|module|function|method|attribute|variable|file|commit)\b/gi;
+
+// every relation verb phrase VERB_TO_KIND knows, as one alternation (longest-first
+// so a multi-word verb like "inherit from" wins over its own leading word "inherit"
+// appearing elsewhere) — feeds the DOES-X-VERB-ANYTHING-ELSE frame below, which needs
+// to recognize "does <subject> <ANY closed relation verb> anything/something [else]"
+// without hardcoding its own parallel verb list.
+const VERB_ALTERNATION = Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
+
 /** Just the curated MISSPELLINGS correction (ask-vocab.mjs), standalone — for a
  *  caller that needs typo-tolerant ANCHOR-WORD matching (a closed regex shape
  *  keyed on a literal "what"/"which"/"where" etc.) without running the rest of
@@ -158,6 +185,25 @@ const EXPLAIN_WRAPPER_RE = /^explain\s+(?:to\s+me\s+|please\s+)*(.+?)\??$/i;
  *  module" -> "describe store module"). */
 const SHOW_GIVE_ME_RE = /^(?:show|give)\s+me\s+(?:the\s+)?(.+?)\??$/i;
 
+/** Leading STACCATO connective before an ALREADY well-formed question ("and
+ *  what imports it", "so does it import anything else", "also where is X
+ *  defined") -> the question alone (0.9.15 Tier-1 single-touch playtest). A
+ *  rapid-fire drill-down naturally opens its next turn with a bare discourse
+ *  connective (chat.mjs's own STACCATO_LEAKED_CONNECTIVES set: and/also/so/
+ *  then/now, here joined by "but" for the same family); when what follows is
+ *  ALREADY an interrogative lead or an auxiliary-question opener, the
+ *  connective carries no query content of its own — conversational
+ *  scaffolding, same species as the greeting/subordination preambles. Gated
+ *  on the REMAINDER starting a real question, so a genuine mid-clause boolean
+ *  composition ("classes that inherit from Base and are tested") is never
+ *  touched — that "and" never sits at position 0 to begin with. Without this,
+ *  "and what imports it" parsed as an "ask"-shape question with "and" itself
+ *  MISREAD as the subject term — a miss the relaxation cascade can't rescue,
+ *  because "and" is protected CONTENT_VOCAB (a boolean connective elsewhere)
+ *  and the noise-strip layer never drops content vocab. */
+const LEADING_CONNECTIVE_RE = /^(?:and|also|so|then|now|but)\s+(.+)$/i;
+const QUESTION_AUX_LEAD_RE = /^(?:does|do|did|is|are|was|were|has|have|had|can|could|will|would|should)\b/i;
+
 /** Apply the closed preamble frames in order (greeting -> modal -> show/give-me),
  *  repeated to a small fixpoint so stacked wrappers ("hey, can you show me X
  *  please") peel fully. Pure and idempotent; unmatched text passes through. */
@@ -180,6 +226,11 @@ export function applyPreambleFrames(text) {
         q = (RELATION_VERB_RE.test(rest) || INTERROGATIVE_LEAD_RE.test(rest)) ? rest : `describe ${rest}`;
       }
     }
+    m = q.match(LEADING_CONNECTIVE_RE);
+    if (m) {
+      const rest = m[1].trim();
+      if (INTERROGATIVE_LEAD_RE.test(rest) || QUESTION_AUX_LEAD_RE.test(rest)) q = rest;
+    }
     if (q === before) break;
   }
   return q;
@@ -343,6 +394,7 @@ export function normalizeQuery(text) {
   q = q.replace(CONTRACTION_RE, (m) => CONTRACTIONS[m.toLowerCase()]);
   q = q.replace(MISSPELLING_RE, (m) => MISSPELLINGS[m.toLowerCase()]);
   q = q.replace(WRONG_WORD_RE, (m) => WRONG_WORDS[m.toLowerCase()]);
+  q = q.replace(KIND_NOUN_ANAPHORA_RE, (_, pron) => pron);
   q = q.replace(G_DROP, "$1ing");
   // closed preamble frames (greeting lead-in, modal wrapper, show/give-me
   // bridge) — AFTER the correction tables (a repaired "give me"/"show me" still
@@ -414,6 +466,23 @@ export const PHRASING_FRAMES = Object.freeze([
   { re: /^(?:the\s+)?(?:members?|methods?|attributes?|contents)\s+of\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `what does ${m[1]} contain` },
   //   "what's in X" / "what is in X" (contraction already expanded; sha handled above)
   { re: /^what\s+is\s+(?:in|inside)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `what does ${m[1]} contain` },
+  //   "what else is in X" (0.9.15 Tier-1 single-touch playtest) — the natural
+  //   "besides what I already know" drill-down after a members-of-class answer.
+  //   Distinct from the "what else does X <verb>" family (which the compositional
+  //   grammar already tolerates, dropping "else" as noise on its own): the "is
+  //   in" idiom is NOT a compositional marker, so parseComposite never sees it and
+  //   "what else is in X" fell through to the strategies with NO candidate at all
+  //   (neither recognizes the bare "is in" idiom once "else" sits in front of it).
+  //   The only rescue was the relaxation cascade's drop-unmatched layer — but that
+  //   layer refuses to accept a relaxed reading that still renders an honest EMPTY
+  //   (by design: relaxation must turn a miss into a real answer, never into
+  //   another kind of miss), so a genuinely empty class ("what else is in
+  //   Task.complete" — a method, no members) bottomed out at the bare grammar
+  //   wall instead of the specific "no contains edges" receipt. Routing this
+  //   frame onto the SAME direct "what does X contain" path the plain "what is
+  //   in X" frame above already uses sidesteps the cascade's conservative gate
+  //   entirely, so a real empty is reported honestly instead of walled.
+  { re: /^what\s+else\s+is\s+(?:in|inside)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `what does ${m[1]} contain` },
 
   // WHERE-DEFINED → "where is X defined". PAST TENSE ONLY ("what defined X", "what
   // declared X"): the PRESENT "what defines X" already parses as a reverse-defines
@@ -512,6 +581,26 @@ export const PHRASING_FRAMES = Object.freeze([
   // survey the bare "what is untested" frame lands on. Closed to the tests/coverage
   // object, so it can't swallow a general "what needs X".
   { re: /^what\s+needs\s+(?:to\s+be\s+)?(?:a\s+)?(?:tested|tests?|testing|coverage|covering)\??$/i, to: () => "untested modules" },
+
+  // DOES-X-VERB-ANYTHING-ELSE → the plain forward "what does X <verb>" listing
+  // (0.9.15 Tier-1 single-touch playtest). A very natural drill-down follow-up
+  // after a relation answer — "does listTasks call anything else", "does
+  // src/handlers/tasks.mjs import something else" — used to dead-end: "anything"/
+  // "something" [else] is a placeholder standing in for "the rest of the list",
+  // not a real object term, but the two parse strategies disagreed on the SPAN
+  // (grammar kept "anything else" whole as the object, keyword-spot dropped
+  // "anything" and kept only "else"), landing on the {ambiguousParse} surface —
+  // two nonsense readings offered as if one might be right. "what does X <verb>"
+  // is the exact working canonical shape (see the MEMBERS-of-class frames above),
+  // so rewriting the whole closed pattern onto it sidesteps the disagreement
+  // instead of teaching either strategy's tokenizer to special-case "else".
+  // Anchored to the closed VERB_TO_KIND vocabulary so it can never swallow a
+  // genuine named object that happens to start with "any"/"some" (only the bare
+  // placeholder nouns "anything"/"something", optionally trailed by "else", match).
+  {
+    re: new RegExp(`^(?:do|does)\\s+(.+?)\\s+(${VERB_ALTERNATION})\\s+(?:anything|something)(?:\\s+else)?\\??$`, "i"),
+    to: (m) => `what does ${m[1]} ${m[2]}`,
+  },
 ]);
 
 /** Apply the phrasing frames (members-of-class + where-defined) — first match wins