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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "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

@@ -912,8 +912,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
@@ -2408,10 +2419,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

@@ -1426,6 +1426,31 @@ function teachSuggestion(payload) {
   return `every ${subject} is ${article} ${object}`;
 }
 
+/** PRONOUN-SUBJECT GUARD (2026-07-08, operator repro): "remember you are a
+ *  womble" and the literal "every you is a womble" both used to reach
+ *  teachSuggestion/unknownSubjectFallback treating "you" like an ordinary
+ *  unknown common noun — producing the nonsensical "did you mean: every you
+ *  is a womble" hint (teachSuggestion), or, worse, a SILENT direct-write via
+ *  unknownSubjectFallback whenever the object happened to resolve as a known
+ *  noun/adjective (e.g. "he is a doctor" would have stored the bogus fact
+ *  "he rdfs:subClassOf doctor"). A personal pronoun is never a valid class-
+ *  membership subject for ANY object — "every <pronoun> is a Y" isn't
+ *  coherent English no matter what Y is, so this is a grammatical category
+ *  error, not "new vocabulary" the unknown-subject free pass exists for.
+ *  Checked FIRST in teachLane, before any other recognizer gets a look at
+ *  the payload (bare OR remember-wrapped surface, so it fires uniformly
+ *  across entry points), and short-circuits with its own honest, distinct
+ *  decline — never the generic "every X is a Y" miss text, and never a "did
+ *  you mean" guess.
+ *
+ *  Deliberately limited to the seven UNAMBIGUOUS personal pronouns (you/i/
+ *  it/they/he/she/we) — this/that/these/those are excluded on purpose: they
+ *  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;
+
 async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   const rawInput = String(query).trim();
   const m = rawInput.match(TEACH_RE);
@@ -1441,6 +1466,24 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   const raw = stripYour(rawInput);
   const wrapped = stripYour(wrappedInput);
 
+  // PRONOUN-SUBJECT GUARD — tried against BOTH surfaces (bare and remember-
+  // wrapped; trailing punctuation stripped the same way the OWNS/SOME_A_FEW
+  // lanes below do) before anything else in this function, so a pronoun
+  // subject NEVER reaches teachSuggestion's "did you mean" hint or
+  // unknownSubjectFallback's direct-write path — see TEACH_PRONOUN_RE's own
+  // docblock above for why.
+  const pronounSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
+  const pronounMatch = pronounSrc.match(TEACH_PRONOUN_RE);
+  if (pronounMatch) {
+    const pronoun = pronounMatch[1];
+    return {
+      text: `I can't store a fact about "${pronoun}" as a class — pronouns aren't things I can classify. `
+        + `I remember facts in the shape "every X is a Y", where X is a specific noun, not a pronoun. `
+        + "Type /memory to see what I already remember.",
+      via: "teach-miss", miss: true,
+    };
+  }
+
   // OWNERSHIP — "<Name> owns/maintains <X>", bare or remember-wrapped. The bare
   // form is double-gated: a Capitalized name AND no interrogative lead, so the
   // "who owns <X>" READ question and ordinary prose never land a fact here.
@@ -1766,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) {
@@ -1815,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;
 }
 
@@ -2830,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
@@ -2848,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) ----
@@ -3252,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
@@ -3336,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
@@ -3353,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;
@@ -3441,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