@polycode-projects/the-mechanical-code-talker 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "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.",
@@ -89,7 +89,8 @@
     "agentbench:run": "node agentbench/run.mjs",
     "infbench": "node infbench/generate-cases.mjs && node infbench/run.mjs",
     "audit": "npm audit --audit-level=high",
-    "audit:fix": "npm audit fix"
+    "audit:fix": "npm audit fix",
+    "demo:build": "node scripts/build-demo-site.mjs"
   },
   "devDependencies": {
     "ink-testing-library": "^4.0.0"

package/src/ask.mjs

@@ -311,7 +311,8 @@ function parseSimpleClause(text, nlp) {
 function parseComposite(text, nlp) {
   const w = splitWords(text);
   const lc = w.map((x) => x.toLowerCase());
-  return parseNegation(text, nlp, 0)
+  return parseExistence(w, lc)
+    || parseNegation(text, nlp, 0)
     || parseForwardNegation(w, lc, nlp)
     || parseTemporal(w, lc, nlp, 0)
     || parseAnaphora(w, lc, nlp)
@@ -580,6 +581,72 @@ function parsePredicateFilter(words, nlp) {
   return undefined;
 }
 
+/** EXISTENCE: "is there a/an <kind> [called|named <term>] [in <module>] [anywhere]"
+ *  and "are there any <kind>(s) [called|named <term>] [in <module>]" — a genuine
+ *  existence question ("does this kind/name exist at all", optionally scoped to a
+ *  module), answered directly against class/kind membership rather than routed
+ *  through the relation-verb machinery. Triage bug (2026-07-09, seonix dogfooding):
+ *  with no dedicated recognizer, "is there a class called Store anywhere" fell
+ *  through to the legacy keyword-spot strategy, whose lemma tier canonicalizes
+ *  "called" -> "call" (a `calls` verb — ask-vocab.mjs) and silently answered a
+ *  DIFFERENT question ("which classes call Store") with a confidently-wrong-shaped
+ *  negative, even though a class named Store genuinely exists. "is there a class in
+ *  <module>" walled out the same way — no marker in this grammar recognized it at
+ *  all. Scoped to a tight closed shape: a leading "is there a/an" or "are there any"
+ *  immediately followed by a recognized entity-kind noun, then ONLY "called"/"named
+ *  <term>", "in <module>", the two combined, or an empty/"anywhere"/"at all" tail —
+ *  anything else (a relative clause, a verb phrase: "is there a class THAT CALLS
+ *  Store") is a genuine relationship question and is left untouched for the
+ *  relation parsers below, never swallowed here. */
+function parseExistence(w, lc) {
+  let i;
+  if (lc[0] === "is" && lc[1] === "there") i = 2;
+  else if (lc[0] === "are" && lc[1] === "there") i = 2;
+  else return null;
+  const article = lc[i];
+  if (article === "a" || article === "an" || article === "any") i += 1;
+  else return null;
+  const noun = i < lc.length ? entityNoun(lc[i]) : null;
+  if (!noun || noun.placeholder || !noun.entityType) return null;
+  const entityType = noun.entityType;
+  i += 1;
+
+  let rest = lc.slice(i);
+  let restW = w.slice(i);
+  // trailing filler — "anywhere" / "at all" — stripped so it never gets misread as
+  // a (nonexistent) module/name term below.
+  if (rest.length && rest[rest.length - 1] === "anywhere") {
+    rest = rest.slice(0, -1); restW = restW.slice(0, -1);
+  } else if (rest.length >= 2 && rest[rest.length - 2] === "at" && rest[rest.length - 1] === "all") {
+    rest = rest.slice(0, -2); restW = restW.slice(0, -2);
+  }
+
+  if (!rest.length) return { node: "exists", entityType, term: null, scopeModule: null };
+
+  if (rest[0] === "called" || rest[0] === "named") {
+    if (rest.length < 2) return { node: "miss", reason: `"${rest[0]}" needs a name afterward` };
+    const inIdx = rest.indexOf("in", 1);
+    if (inIdx > 0) {
+      const term = restW.slice(1, inIdx).join(" ").trim();
+      const scopeModule = restW.slice(inIdx + 1).join(" ").trim();
+      if (!term || !scopeModule) return { node: "miss", reason: `a named existence check needs both a name and a module after "in"` };
+      return { node: "exists", entityType, term, scopeModule };
+    }
+    const term = restW.slice(1).join(" ").trim();
+    return term ? { node: "exists", entityType, term, scopeModule: null }
+      : { node: "miss", reason: `"${rest[0]}" needs a name afterward` };
+  }
+
+  if (rest[0] === "in") {
+    const scopeModule = restW.slice(1).join(" ").trim();
+    return scopeModule ? { node: "exists", entityType, term: null, scopeModule }
+      : { node: "miss", reason: `"in" needs a module afterward` };
+  }
+
+  return null; // a relative clause / verb phrase / anything else — genuinely a
+               // different (relationship) question; leave it for the parsers below.
+}
+
 /** 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,
@@ -912,8 +979,19 @@ function parseRelationalOrQualified(w, lc, nlp, depth) {
     // auxiliary in that position ("what DID commit X touch") is left for the existing
     // parser, not mistaken for a term.
     const nextNoun = i + 1 < lc.length ? entityNoun(lc[i + 1]) : null;
+    // CASCADE_NOISE_SET excluded alongside STOPWORDS (Tier-2 playtest, cycle 8):
+    // "what about classes"/"how about the modules" used to reach here with
+    // "about" sitting right where a real qualifying adjective would ("payment"
+    // in "list payment modules") — framed (past "what") and immediately before
+    // a known noun ("classes") — and get misread as a fuzzy find TERM ("no
+    // classes found matching 'about'") instead of the topic-lead-in filler it
+    // is. CASCADE_NOISE already curates "about" for exactly this reading (see
+    // its own docblock, ask-vocab.mjs) — checking it here too lets a real
+    // unknown qualifier ("shiny"/"payment") still reach the find fallback while
+    // a known no-graph-meaning filler word falls through to the ordinary bare-
+    // kind-noun path instead (the cascade's own noise-strip terminal rule).
     if ((framed || quals.length) && nextNoun && /^[a-z]+$/.test(lc[i])
-      && !VERB_TO_KIND[lc[i]] && !STOPWORDS.has(lc[i])) {
+      && !VERB_TO_KIND[lc[i]] && !STOPWORDS.has(lc[i]) && !CASCADE_NOISE_SET.has(lc[i])) {
       return { node: "find", entityType: nextNoun.entityType, term: w[i] };
     }
     return null;                                   // no subject entity → not this shape
@@ -1468,10 +1546,42 @@ function evalSuperlative(graph, ast) {
   return { compositeKind: "superlative", entityType: ast.entityType, metricNoun: ast.metricNoun, extreme: ast.extreme, score: best, matches: winners };
 }
 
+/** EXISTENCE eval — "is there a/an <kind> [called/named <term>] [in <module>]": a
+ *  direct membership/name check against the graph, never routed through the
+ *  relation-verb machinery. A named check resolves the term against the SAME
+ *  tiered resolveObject() every other named-lookup shape uses (expectedClass pins
+ *  the pool to the asked kind, so "is there a class called Store" can never
+ *  resolve to a same-named function/module); a scope clause resolves the module
+ *  the same way and narrows the check to that module's own `defines` edges
+ *  (refineToEntities — the same primitive members-of-a-module questions use). */
+function evalExists(graph, ast) {
+  const { entityType, term, scopeModule } = ast;
+  let scopeMatch = null;
+  if (scopeModule) {
+    const r = resolveObject(graph, scopeModule, { expectedClass: "Module" });
+    if (!r.match) return { compositeKind: "exists", entityType, term, scopeModule, scopeMiss: true, matches: [] };
+    scopeMatch = r.match;
+  }
+  if (term) {
+    const r = resolveObject(graph, term, { expectedClass: entityType });
+    const inScope = !scopeMatch || (r.match && moduleIdOf(graph, r.match) === scopeMatch.id);
+    const hit = r.match && inScope;
+    return {
+      compositeKind: "exists", entityType, term, scopeModule, scopeMatch,
+      matches: hit ? [r.match] : [],
+    };
+  }
+  const pool = scopeMatch
+    ? refineToEntities(graph, new Set([scopeMatch.id]), entityType)
+    : graph.individuals.filter((i) => i.class === entityType);
+  return { compositeKind: "exists", entityType, term: null, scopeModule, scopeMatch, matches: pool };
+}
+
 /** 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 === "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);
@@ -1521,6 +1631,30 @@ function renderComposite(parsed, result) {
     }
     return { content: `couldn't compile this compositional question${result.reason ? ` (${result.reason})` : ""}. ${compositionalHint()}.`, miss: true, ambiguous: false };
   }
+  // exists: "is there a/an <kind> [called/named <term>] [in <module>]" — an
+  // honest Yes/No membership check, never routed through the relation-verb
+  // machinery (see parseExistence's own doc for the bug this fixes).
+  if (result.compositeKind === "exists") {
+    if (result.scopeMiss) {
+      return { content: `no module matching "${result.scopeModule}" found in the index.`, miss: true, ambiguous: false };
+    }
+    const kindSingular = nounFor(result.entityType, 1);
+    const kindPlural = nounFor(result.entityType, 2);
+    const scopeSuffix = result.scopeMatch ? ` in ${result.scopeMatch.label}` : "";
+    if (result.term) {
+      if (!result.matches.length) {
+        return { content: `No — no ${kindSingular} named "${result.term}" found${scopeSuffix}.`, miss: true, ambiguous: false };
+      }
+      const hit = result.matches[0];
+      const modLabel = moduleLabelOf(hit);
+      const definedIn = hit.class === "Module" ? "" : (modLabel && modLabel !== "(unknown module)" ? `, defined in ${modLabel}` : "");
+      return { content: `Yes — ${hit.label} is a ${kindSingular}${definedIn}.`, miss: false, ambiguous: false, matches: result.matches };
+    }
+    if (!result.matches.length) {
+      return { content: `No — no ${kindPlural} found${scopeSuffix}.`, miss: true, ambiguous: false };
+    }
+    return { content: `Yes — ${compositeList(result.matches)}${scopeSuffix}.`, 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: [] };
@@ -2408,10 +2542,20 @@ function renderCore(parsed, result) {
   if (!result.objMatch && (!result.candidates || result.candidates.length === 0) && parsed.shape !== "ask") {
     // name what kind of thing was looked for: a sha-shaped term was checked against
     // the commit namespace, a dotted slash-free term against symbol labels — a
-    // generic "no module matching" would misreport both.
+    // generic "no module matching" would misreport both. Those two TERM-SHAPE
+    // reads keep priority (a bare "a.mjs" is deliberately read as a symbol-ish
+    // shorthand regardless of the stated entity type — frozen by
+    // test/chat.test.mjs's "no symbol matching \"a.mjs\"" case); only the
+    // remaining catch-all default (unconditionally "module") is replaced by the
+    // parsed AST's own entityType when one is present (Tier-2 playtest, cycle 8
+    // — "which classes inherit from Widget" used to say "no MODULE matching
+    // 'Widget'" even though entityType="Class" was sitting right there unused,
+    // and "Widget" is neither sha- nor dotted-symbol-shaped so the catch-all is
+    // exactly what fired).
     const objText = String(parsed.object || "").trim();
+    const fallback = parsed.entityType && PLURAL_FORMS[parsed.entityType] ? nounFor(parsed.entityType, 1) : "module";
     const what = /^(?:commit[:\s])?[0-9a-f]{7,40}$/i.test(objText) ? "commit"
-      : (!objText.includes("/") && /^[\w$]+(\.[\w$]+)+$/.test(objText) ? "symbol" : "module");
+      : (!objText.includes("/") && /^[\w$]+(\.[\w$]+)+$/.test(objText) ? "symbol" : fallback);
     return {
       content: `no ${what} matching "${parsed.object}" found in the index.`,
       miss: true, ambiguous: false, candidates: [],

package/src/chat.mjs

@@ -1809,6 +1809,24 @@ const PERSONAL_ASSISTANT_NUDGE_RE = new RegExp(
 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;
 
+/** STACCATO COMPARATIVE (SKILL_CHAT_PLAYTEST Tier-2, 6th pass, cycle 8 —
+ *  cycle 7's own recommendation): "more than that", "which is bigger", "is
+ *  there anything bigger", "bigger than that" following a superlative answer
+ *  ("which module has the most imports" -> "src/handlers/tasks.mjs — 5").
+ *  Genuinely unanswerable as a real graph query, never fabricated: tmct's
+ *  superlative only ever names the single top (or bottom) match for a metric
+ *  (evalSuperlative) — it has no "runner-up"/"next ranked" or "greater than a
+ *  number" capability to reach for. Before this, both a short/non-codeish
+ *  phrasing ("more than that") and the wall these route to (once the
+ *  isConversational catch-all is deferred below) fell to the generic
+ *  orientation card or the raw grammar wall — neither says what actually went
+ *  wrong. Same "honest, guiding nudge, never a bare wall" discipline as
+ *  STACCATO_NEGATION_RE just above; the standing focus (now the superlative
+ *  WINNER after the chat.mjs fix that made a superlative set it) names what
+ *  the user can compare against directly. */
+const STACCATO_COMPARATIVE_RE =
+  /^(?:(?:is\s+there\s+|what(?:'s|\s+is)\s+)?(?:anything|something)?\s*(?:more|bigger|larger|smaller|fewer|less)\s*(?:than\s+(?:that|it|this))?|which(?:\s+one)?\s+is\s+(?:bigger|smaller|larger|more|less))\s*\??$/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) {
@@ -1858,6 +1876,31 @@ function nudgeAnswer(query, focus) {
     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.`;
   }
+  if (STACCATO_COMPARATIVE_RE.test(q)) {
+    const name = focus?.label;
+    return "I only name the single top (or bottom) match for a metric — no runner-up ranking, no comparing against a number. "
+      + (name
+        ? `Ask about a specific module/class/function directly to compare it with ${name} (e.g. "how many imports does <name> have").`
+        : `Ask a specific ranking directly, e.g. "which module has the most imports".`);
+  }
+  // A bare STACCATO PRONOUN continuation ("also that one?", "and it") with NO
+  // standing focus at all (Tier-2 playtest, 6th pass, cycle 8): describeWrapperAnswer
+  // (4d, below) already resolves this shape perfectly when a real focus stands
+  // (T18) — it honestly DECLINES (null) when there is none, same discipline as
+  // every other focus-dependent lane. Before this branch, that decline fell
+  // through all the way to the generic multi-line orientation card, which names
+  // nothing about what actually went wrong. Symmetric with STACCATO_NEGATION_RE's
+  // own no-focus nudge just above ("not sure what you'd like instead… — name it
+  // directly"): a positive pronoun with nothing to point at gets the same honest,
+  // tailored decline instead of the wall. (Exposed by the STACCATO_LEAKED_CONNECTIVES
+  // fix in runAsk: "what about imports" -> "and calls?" no longer silently — and
+  // WRONGLY — installs a substring-matched module as focus, so a chain of two
+  // vague relation touches genuinely has no antecedent for a third "also that
+  // one?" to resolve — this nudge is what such a chain should always have gotten.)
+  const pronounContinuation = q.match(STACCATO_PRONOUN_RE);
+  if (pronounContinuation && !focus?.label) {
+    return `not sure what "${pronounContinuation[1].toLowerCase()}" refers to yet — name something directly, e.g. "what calls <name>".`;
+  }
   return null;
 }
 
@@ -2873,6 +2916,22 @@ const NAME_TOKEN_RE = /\b[\w-]+(?:[/.][\w-]+)+\b|\b[A-Z][A-Za-z0-9_]*\b|\b[a-z][
  *  matches and falls through unchanged. */
 const STACCATO_SWAP_RE = /^(?:and|also|so|then|now)\s+(.+?)[?.!\s]*$/i;
 
+/** The five bare connective words STACCATO_SWAP_RE/relationTermOf's own STACCATO
+ *  branch lead with. Reused (runAsk's focus-resolution guard, below) to catch
+ *  the case where ask()'s OWN raw grammar, given an unstripped "and calls?",
+ *  happens to recognize "calls" as a verb and leaves the leading "and" as
+ *  parsed.object — a leaked connective, never real content, must never be fed
+ *  to resolveEntity (see that guard's own docblock for the concrete failure). */
+const STACCATO_LEAKED_CONNECTIVES = new Set(["and", "also", "so", "then", "now"]);
+
+/** A whole-word occurrence of one of chat.mjs's own closed antecedent pronouns
+ *  (CONTEXT_WORDS: "it"/"this"/"that"/"here") inside a PRIOR turn's raw query
+ *  text — discourseRewrite's fallback swap target when that text has no real
+ *  NAME_TOKEN at all ("what calls it", "where is it defined"). Word-boundary
+ *  anchored so a real identifier merely CONTAINING one of these (e.g. a symbol
+ *  named `edithistory`) is never mistaken for the pronoun. */
+const PRONOUN_IN_QUERY_RE = new RegExp(`\\b(?:${[...CONTEXT_WORDS].join("|")})\\b`, "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
  *  the previous subject/object. Returns the reconstructed query (parsed like any
@@ -2891,8 +2950,51 @@ function discourseRewrite(query, last) {
   }
   if (!last?.query) return null;
   const prevQ = String(last.query);
-  if (!NAME_TOKEN_RE.test(prevQ)) return null;
-  return prevQ.replace(NAME_TOKEN_RE, () => newSubj);
+  if (NAME_TOKEN_RE.test(prevQ)) return prevQ.replace(NAME_TOKEN_RE, () => newSubj);
+  // PRONOUN-ANTECEDENT PRIOR QUERY (Tier-2 playtest, 6th pass, cycle 8, deep
+  // multi-hop relation-touch chain stress-test): the prior turn can ITSELF be
+  // pronoun-shaped ("what calls it", "where is it defined" — a drill-down
+  // step that resolved "it" against the standing focus rather than naming an
+  // entity literally) — such a query has NO NAME_TOKEN at all to swap, so the
+  // rule above always declined and a perfectly natural next hop ("and Task?"
+  // meaning "and what calls Task?") fell straight to the raw grammar wall.
+  // Swap the bare pronoun itself in that case ("what calls it" -> "what calls
+  // Task") — CONTEXT_WORDS is chat.mjs's own closed antecedent-pronoun set
+  // (the same one isPronoun/the focus-reuse guard above already trust), so
+  // this only ever touches a genuine referring pronoun, never a real word
+  // that happens to contain "it"/"this"/"that" as a substring (whole-word
+  // boundaries only).
+  if (PRONOUN_IN_QUERY_RE.test(prevQ)) return prevQ.replace(PRONOUN_IN_QUERY_RE, () => newSubj);
+  return null;
+}
+
+/** STACCATO SUPERLATIVE REPEAT (Tier-2 playtest, 6th pass, cycle 8): "the biggest
+ *  one" / "which is biggest" / "which one is the biggest" / "what about the
+ *  biggest one" continuing a superlative last turn ("which module has the most
+ *  imports") names NO entity kind at all — parseSuperlative's own grammar always
+ *  declines that shape ("a superlative needs an entity kind (module, class,
+ *  function, …)"), the one piece of information every OTHER superlative phrasing
+ *  supplies, and unlike a plain object ("what does it import") there is no
+ *  pronoun slot here for the focus to fill. Rather than guess a NEW metric — a
+ *  bare "biggest" with an entity kind spliced in would default to the generic
+ *  "connections" metric (EDGE_NOUN_TO_METRIC.connections), which is NOT what
+ *  "the biggest one" means right after a query about imports specifically, and
+ *  would silently answer a different question than the one just asked — this
+ *  re-asks the PRIOR superlative query VERBATIM: the user is confirming/
+ *  repeating the same ranking in their own words, not asking a new one, so
+ *  replaying the exact prior text (same entityType, same metric) is the only
+ *  non-fabricating reading. Gated on the prior query textually naming an extreme
+ *  word — a bare "the biggest one" after an unrelated last turn declines (null)
+ *  and the ordinary honest miss stands, same discipline as discourseRewrite's
+ *  own NAME_TOKEN_RE gate just above. */
+const STACCATO_SUPERLATIVE_RE =
+  /^(?:what about\s+)?(?:(?:and|also|so|then|now)\s+)?(?:which(?:\s+one)?\s+is\s+(?:the\s+)?|the\s+)(?:most|greatest|highest|biggest|largest|fewest|least|smallest)(?:[- ]connected)?(?:\s+ones?)?\s*\??$/i;
+const SUPERLATIVE_EXTREME_WORD_RE = /\b(?:most|greatest|highest|biggest|largest|fewest|least|smallest)\b/i;
+function superlativeRepeatRewrite(query, last) {
+  if (!STACCATO_SUPERLATIVE_RE.test(String(query).trim())) return null;
+  const prevQ = String(last?.query || "");
+  if (!prevQ || !SUPERLATIVE_EXTREME_WORD_RE.test(prevQ)) return null;
+  return prevQ;
 }
 
 // ---- curated SEON definitions (corpus/seon/definitions.jsonl) ----
@@ -3295,7 +3397,7 @@ 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.
-  let askQuery = discourseRewrite(query, last) ?? query;
+  let askQuery = superlativeRepeatRewrite(query, last) ?? 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
@@ -3379,14 +3481,47 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // it becomes the new focus so a follow-up "what calls it" can reuse it.
   let resolvedIds = [];
   let newFocus = focus;
-  if (graph && envelope?.parsed?.object) {
+  // STACCATO CONNECTIVE LEAKAGE (Tier-2 playtest, 6th pass, cycle 8, multi-hop
+  // relation-touch chain stress-test): "and calls?" — the bare-connective
+  // relation-chain continuation STACCATO_SWAP_RE/relationTermOf's own STACCATO
+  // branch both recognize — is handed to ask() UNSTRIPPED as askQuery. When
+  // ask()'s own raw grammar happens to recognize "calls" as a verb (VERB_TO_KIND),
+  // the leftover "and" becomes parsed.object, and resolveObject's tier-3
+  // substring match (`label.includes(tLc)`) has no minimum-length floor — a
+  // 2-3 letter connective is a near-certain accidental substring of SOME real
+  // label ("and" -> Controller.h-AND-le). The visible answer still looks fine
+  // (relationForceAnswer, later, composes the correct generic relation text
+  // over the SAME query) — but this block ran FIRST and silently rebound the
+  // FOCUS to that bogus match, so the NEXT turn's pronoun ("what tests it")
+  // resolved against the wrong entity and rendered a confidently WRONG empty
+  // ("no tests cover it") for a module that genuinely has tests. The exact
+  // same class of bug as CHATBENCH_0.7.1's "it" reuse-focus fix just below —
+  // grammar scaffolding leaked into the object slot is never real content, so
+  // (mirroring that fix's own discipline) any of the five closed connective
+  // words STACCATO_SWAP_RE recognizes is excluded here from ever being resolved
+  // as an object at all: the branch is skipped entirely, leaving the standing
+  // focus untouched for the relation force (or ordinary miss) to answer over.
+  const isLeakedConnective = STACCATO_LEAKED_CONNECTIVES.has(String(envelope?.parsed?.object || "").toLowerCase());
+  if (graph && envelope?.parsed?.object && !isLeakedConnective) {
     const obj = envelope.parsed.object;
     // A PRONOUN object ("it"/"this") was already resolved against the focus via
     // contextId — the resolved antecedent IS the focus. Re-resolving the literal
     // pronoun string is the CHATBENCH_0.7.1 B1-pron bug: "it" substring-matches the
     // "Commit" schema node (label contains "it"), so the focus jumped off the module
-    // to a Commit and the NEXT "it" bound wrong. Reuse the focus directly instead.
-    const ent = (isPronoun(obj) && focus?.id) ? focus : await resolveEntity(graph, obj);
+    // to a Commit and the NEXT "it" bound wrong. Reuse the focus directly instead —
+    // and when there is NO focus to reuse (Tier-2 playtest, 6th pass, cycle 8: a
+    // bare "where is it defined"/"what does it import" with nothing standing yet,
+    // or right after a superlative TIE, which deliberately never sets one — see
+    // the superlative-winner branch below), never fall through to resolveEntity on
+    // the raw pronoun string either: that is the EXACT SAME substring-match trap
+    // (a 2-letter "it" is a near-certain accidental substring of SOME real label —
+    // here, Task.t-IT-le) as STACCATO_LEAKED_CONNECTIVES fixes for "and"/"also"
+    // above, just triggered by a pronoun instead of a connective. ask()'s OWN
+    // evaluation already renders the honest "'it' needs a selected node…" miss in
+    // this case (contextId was null); silently adopting a bogus focus as a side
+    // effect here would corrupt the NEXT turn's pronoun into a confidently WRONG
+    // (not just empty) answer, exactly as the connective leak did.
+    const ent = isPronoun(obj) ? (focus?.id ? focus : null) : await resolveEntity(graph, obj);
     if (ent) {
       resolvedIds = [ent.id];
       // Class-gate the focus update: a Commit/Session/schema object never displaces a
@@ -3396,6 +3531,23 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     } else if (!isPronoun(obj)) {
       note(trace, `intermediate: object "${obj}" did NOT resolve to a graph entity — this is why an otherwise-parsed query still misses`);
     }
+  } else if (graph && envelope?.parsed?.node === "superlative" && Array.isArray(envelope?.matches) && envelope.matches.length === 1) {
+    // A superlative ("which module has the most imports") names no object at all —
+    // the branch above never runs — so the ranked WINNER never became the focus,
+    // and an immediate natural follow-up ("what does it import", "where is it
+    // defined") dead-ended on "'it' needs a selected node to refer to" right after
+    // the engine had just named one. Mirrors the object-resolution rule above
+    // exactly: a single, unambiguous winner (no tie — a multi-way tie names no
+    // one individual, so the focus is left alone rather than guessing which of
+    // the tied matches the user means) becomes the new focus, class-gated the
+    // same way (nextFocus). Found in Tier 2 playtest, cycle 8 (superlative
+    // follow-up chains, SKILL_CHAT_PLAYTEST.md).
+    const winner = envelope.matches[0];
+    if (winner?.id) {
+      resolvedIds = [winner.id];
+      newFocus = nextFocus(graph, focus, winner);
+      note(trace, `result: superlative winner ${winner.label} (${winner.id}) — becomes the new focus`);
+    }
   }
   const answeredIds = (envelope?.matches || []).map((m) => m?.id).filter(Boolean);
   const miss = envelope ? !!envelope.miss : true;
@@ -3484,7 +3636,50 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // 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) {
+  // Staccato comparative ("more than that", "which is bigger", "is there
+  // anything bigger" — Tier-2 playtest, 6th pass, cycle 8) needs the SAME
+  // deferral, for the SAME reason as isStaccatoNegation just above: these are
+  // short/non-codeish and trip isConversational's ≤3-word catch-all before
+  // nudgeAnswer's own STACCATO_COMPARATIVE_RE branch ever gets a turn.
+  // nudgeAnswer's comparative branch ALWAYS returns a tailored nudge for this
+  // shape, never null, so deferring here never strands the turn unclaimed.
+  const isStaccatoComparative = STACCATO_COMPARATIVE_RE.test(String(query).trim());
+  // A bare STACCATO PRONOUN continuation ("also that one?", "and it") with NO
+  // standing focus (Tier-2 playtest, 6th pass, cycle 8) needs the SAME deferral:
+  // nudgeAnswer's own STACCATO_PRONOUN_RE-no-focus branch (just above) ALWAYS
+  // returns a tailored nudge for this exact shape, never null, so deferring
+  // here never strands the turn unclaimed — see that branch's own docblock for
+  // why the no-focus case must never reach the generic orientation card.
+  const isStaccatoPronounNoFocus = STACCATO_PRONOUN_RE.test(String(query).trim()) && !focus?.label;
+  // A vague relation touch ("what about cochange", "tell me about cochange",
+  // the staccato chain continuation "and cochange?") whose relation word has NO
+  // bare single-word VERB_TO_KIND form of its own needs the SAME deferral as
+  // isExplainTouch just above, for the identical reason: "cochange" is the one
+  // relation (ask-vocab.mjs RELATIONS.cochange) whose every registered verb
+  // phrase takes a preposition ("changed WITH X", "changes together WITH X") —
+  // there is no bare "cochanges X" — so ask() never gives this shape a parse to
+  // hang envelope.parsed off of, unlike its siblings (imports/calls/tests/
+  // inherits/contains/defines/touches/reexports all have a bare verb and so
+  // already escape isConversational's ≤3-word catch-all via envelope.parsed).
+  // 0.9.16 Tier-2 playtest, 6th pass: "what about cochange" as an opening turn,
+  // and "and cochange?" as a mid-chain continuation after a working "what about
+  // tests", both fell straight to the generic orientation card even though the
+  // graph has real cochange edges and every sibling relation word already
+  // flowed. Needs no prior-turn/focus context either (same as isExplainTouch) —
+  // scoped to the CLOSED RELATION_TERM vocabulary (concept.mjs) via
+  // relationTermOf's own gate, so an unknown word or a real entity name still
+  // declines and isConversational's catch-all is untouched for it.
+  let isVagueRelationTouch = false;
+  {
+    const relTerm = relationTermOf(String(query), envelope);
+    if (relTerm) {
+      try {
+        const { RELATION_TERM } = await import("./concept.mjs");
+        isVagueRelationTouch = !!RELATION_TERM[relTerm.toLowerCase()];
+      } catch { /* leave false — the ordinary path decides */ }
+    }
+  }
+  if (!handled && miss && !envelope?.parsed && isConversational(query) && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus) {
     // 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