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

package/package.json

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

@@ -291,6 +291,14 @@ const NEST_SENTINEL = "zzinnerset";
 // then"/"what about X though".
 const PRED_LEAD_SKIP = new Set(["that", "which", "who", "are", "is", "was", "were", "do", "does", "also", "still", "both", "and", "then", "though"]);
 const FRAME_WORDS = new Set(["which", "what", "who", "list", "show", "find", "give", "me", "us", "all"]);
+// A bare copula leading a boolean branch ("...and ARE untested") is discourse glue,
+// not part of the qualifier — dropped before a branch is tested/used as a
+// qualifier-only atom (both the marker-gate probe below and the two atom-building
+// folds — buildPredicateAtoms, parseRelationalOrQualified's own fold — apply it).
+const COPULA_WORDS = new Set(["are", "is", "was", "were"]);
+function dropLeadCopula(bw, blc) {
+  return blc.length && COPULA_WORDS.has(blc[0]) ? { bw: bw.slice(1), blc: blc.slice(1) } : { bw, blc };
+}
 
 const entityNoun = (w) => (ENTITY_TO_TYPE[w] ? { entityType: ENTITY_TO_TYPE[w], placeholder: false }
   : (PLACEHOLDER_NOUNS.includes(w) ? { entityType: null, placeholder: true } : null));
@@ -312,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)
@@ -647,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,
@@ -930,7 +976,8 @@ function buildPredicateAtoms(entityType, subjPrefix, predLc, predWords, nlp, dep
     const bw = branches[b];
     const blc = bw.map((x) => x.toLowerCase());
     const op = b === 0 ? "intersection" : ops[b - 1];
-    if (bw.length && blc.every((x) => QUALIFIERS[x])) { atoms.push({ op, kind: "qual", filters: blc }); continue; }
+    const qc = dropLeadCopula(bw, blc);
+    if (qc.blc.length && qc.blc.every((x) => QUALIFIERS[x])) { atoms.push({ op, kind: "qual", filters: qc.blc }); continue; }
     if (blc[0] === "of" || blc[0] === "in") {
       atoms.push({ op, kind: "set", ast: { node: "membership", entityType, term: bw.slice(1).join(" ") } });
       continue;
@@ -1005,9 +1052,20 @@ function parseRelationalOrQualified(w, lc, nlp, depth) {
   if (predLc.length && RELATIVE_PRONOUNS.includes(predLc[0])) { relFlag = true; predLc = predLc.slice(1); predWords = predWords.slice(1); }
   const membershipLed = predLc[0] === "of" || predLc[0] === "in";
   const gerundLed = predLc.length > 0 && isGerundVerb(predLc[0]);
+  // A boolean branch whose OWN content — past an optional leading copula ("and ARE
+  // untested") — collapses to qualifier words alone is the compositional shape too
+  // ("functions that call X and are untested": verb clause AND qualifier, same
+  // subject). Probe with the same splitBoolean+QUALIFIERS fold the atoms loop below
+  // uses, so a bare verb+verb boolean chain with NO qualifier signal anywhere
+  // ("which classes extends Base and couples to logging") still has no marker here
+  // and correctly stays on the legacy ambiguous-parse path, untouched.
+  const boolQualLed = predWords.length > 0 && splitBoolean(predLc, predWords).branches.some((bw) => {
+    const { blc } = dropLeadCopula(bw, bw.map((x) => x.toLowerCase()));
+    return blc.length && blc.every((x) => QUALIFIERS[x]);
+  });
   // 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)) return null;
+  if (!(quals.length || relFlag || membershipLed || gerundLed || boolQualLed)) return null;
 
   // empty predicate → a bare qualified class ("public methods")
   if (!predWords.length) {
@@ -1026,7 +1084,8 @@ function parseRelationalOrQualified(w, lc, nlp, depth) {
     const bw = branches[b];
     const blc = bw.map((x) => x.toLowerCase());
     const op = b === 0 ? "seed" : ops[b - 1];
-    if (bw.length && blc.every((x) => QUALIFIERS[x])) { atoms.push({ op, kind: "qual", filters: blc }); continue; }
+    const qc = dropLeadCopula(bw, blc);
+    if (qc.blc.length && qc.blc.every((x) => QUALIFIERS[x])) { atoms.push({ op, kind: "qual", filters: qc.blc }); continue; }
     if (blc[0] === "of" || blc[0] === "in") {
       atoms.push({ op, kind: "set", ast: { node: "membership", entityType, term: bw.slice(1).join(" ") } });
       continue;
@@ -1577,11 +1636,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);
@@ -1655,6 +1732,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: [] };
@@ -1861,15 +1959,66 @@ export function resolveObject(graph, term, { expectedClass = null } = {}) {
       }
     }
   } else {
-    const termComps = componentSet(t);
+    // Root-cause fix (Tier-2 playtest cycle 9, targeted substring-match sweep):
+    // this raw containment check has no minimum-length floor, so a short
+    // closed-vocabulary word is a near-certain ACCIDENTAL substring of SOME
+    // real label — confirmed empirically against the shipped mini-webapp
+    // fixture: "so"->sendJson, "or"->Store, "a"->Task, "is"->listTasks
+    // (ambiguous), "in"->Logger.info, "on"->sendJson, "at"->createApp,
+    // "to"->Store, all via this exact branch. Cycle 8 patched three of these
+    // ("and"/"also"/"so"/"then"/"now" and bare "it") one word at a time at
+    // individual chat.mjs CALL SITES (STACCATO_LEAKED_CONNECTIVES, the
+    // pronoun-reuse guard) — necessary there because those bugs are about
+    // FOCUS bookkeeping, not resolution per se, but leaving resolveObject
+    // itself unguarded meant every OTHER caller (existence checks, expectedClass
+    // lookups, etc.) stayed exposed to the same trap for every not-yet-hit
+    // short word. Gating the containment check at the same floor tier 5's own
+    // fuzzy pass already uses (`tLc.length >= 4` below) closes it at the
+    // source. A whole-token component match (just below) is unaffected by this
+    // floor — it requires an EXACT path/identifier segment equality, never a
+    // raw substring, so a genuinely short real identifier ("db", "fs") is
+    // still resolvable by literally matching a whole segment.
+    const termComps = [...componentSet(t)];
+    // A SLASHED term's final path segment, extension stripped ("src/nope.mjs"
+    // -> "nope", "cover app/lib/b.mjs" -> "b") — the semantically load-bearing
+    // FILENAME STEM, as opposed to a directory segment or a leaked verb noise
+    // word. Isolated from the actual whitespace-delimited PATH TOKEN (not the
+    // raw multi-word string as a whole) — "app/lib/f.mjs but untested" (a
+    // trailing-noise leak, distinct from the leading-verb-noise shape above)
+    // has no extension at the end of the whole string, so splitting the whole
+    // string would strand "f.mjs but untested" as a bogus non-matching "stem";
+    // finding the one token that itself contains "/" keeps the path term
+    // intact regardless of what noise surrounds it on either side. Only
+    // slash-shaped terms compute this; a bare identifier/multi-word query has
+    // no path structure to anchor on, so it's null and the gate below is a
+    // no-op for those (unaffected — original ANY-overlap behavior).
+    const pathToken = tLc.split(/\s+/).find((tok) => tok.includes("/"));
+    const slashStem = pathToken ? pathToken.split("/").pop().replace(/\.[a-z0-9]+$/, "") : null;
     for (const m of pool) {
       const label = String(m.label || "").toLowerCase();
-      if (label.includes(tLc)) {
+      if (tLc.length >= 4 && label.includes(tLc)) {
         scored.push({ ind: m, score: 1000 - Math.abs(label.length - tLc.length) });
         continue;
       }
-      const overlap = [...termComps].filter((c) => componentSet(m.label).has(c)).length;
-      if (overlap > 0) scored.push({ ind: m, score: overlap * 10 });
+      const labelComps = componentSet(m.label);
+      const overlap = termComps.filter((c) => labelComps.has(c)).length;
+      // For a slashed term, the stem MUST be among the label's own components
+      // — an ANY-overlap match otherwise lets a NONEXISTENT path land on a
+      // real module that merely shares its generic directory/extension
+      // segments ("src", "mjs") with every other module in the pool (found
+      // via the existence recognizer's "is there a class in src/nope.mjs"
+      // scope clause, Tier-2 playtest cycle 9: it ambiguously "matched"
+      // src/core/model.mjs even though no such module exists — the same
+      // accidental-match disease as the short-word substring bug just above,
+      // just triggered by GENERIC components instead of raw containment).
+      // A leaked leading VERB ("cover app/lib/b.mjs", "touch app/lib/f.mjs" —
+      // router-interface.test.mjs's own frozen contract) still resolves: the
+      // stem ("b"/"f") is a real component of the target label even though
+      // "cover"/"touch" themselves never overlap anything, so overlap>0 and
+      // the stem gate both hold.
+      if (overlap > 0 && (!slashStem || labelComps.has(slashStem))) {
+        scored.push({ ind: m, score: overlap * 10 });
+      }
     }
   }
   scored.sort((a, b) => b.score - a.score);
@@ -1890,12 +2039,24 @@ export function resolveObject(graph, term, { expectedClass = null } = {}) {
   // browser `lookupByProseTokens` is an undeclared identifier — without the guard,
   // ANY term reaching this tier threw a ReferenceError in the page instead of
   // rendering the honest miss (a real, previously-untested viewer bug).
-  // DOTTED terms never consult prose: "res.json" word-matches test/res.json.js's
-  // own path tokens, which is the tier-3 phantom-path bug reappearing through a
-  // side door — a dotted term names an identifier, and identifiers resolve by
-  // label (tiers above) or the bounded fuzzy pass below, or they honestly miss.
+  // DOTTED or SLASHED terms never consult prose: "res.json" word-matches
+  // test/res.json.js's own path tokens, which is the tier-3 phantom-path bug
+  // reappearing through a side door — a dotted term names an identifier, and
+  // identifiers resolve by label (tiers above) or the bounded fuzzy pass
+  // below, or they honestly miss. The SAME side door was open for SLASHED
+  // path terms too (Tier-2 playtest cycle 9, existence-recognizer follow-up):
+  // "src/nope.mjs" — a nonexistent module — no longer false-matches tier 3
+  // (the AND-across-components fix just above), but fell through to THIS
+  // prose tier and ambiguously "matched" real modules anyway, because
+  // lookupByProseTokens scores by ANY-token overlap (sum-scored, by design,
+  // for genuine prose ranking) and "src"/"mjs" are near-universal path/
+  // extension tokens shared by every module in the pool — the identical
+  // accidental-match disease, just one tier further down. A slash-shaped term
+  // names a literal path exactly like a dotted term names a literal symbol;
+  // neither is prose, so neither should ever reach the prose fallback.
+  const pathShaped = dotted || tLc.includes("/");
   let proseResult = null;
-  const proseHits = !dotted && typeof lookupByProseTokens === "function"
+  const proseHits = !pathShaped && typeof lookupByProseTokens === "function"
     ? lookupByProseTokens(graph.proseIndex, t).filter((h) => !expectedClass || graph.byId.get(h.id)?.class === expectedClass)
     : [];
   if (proseHits.length) {
@@ -2910,10 +3071,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

@@ -3300,7 +3300,13 @@ async function describeWrapperAnswer(query, { config, source, focus }) {
  *  known edge concept (RELATION_TERM), no curated definition, or the graph has NO
  *  edges of that kind (composeRelation's own honest-miss gate). Loads the definition
  *  from the shipped corpus/seon/relations.jsonl, so it works without per-repo memory
- *  seeding. Lazy + failure-tolerated throughout. Returns { text, pending }. */
+ *  seeding. Lazy + failure-tolerated throughout. Returns { text, pending, kind } —
+ *  `kind` is the resolved RELATION_TERM canonical kind (imports/calls/…), the SAME
+ *  vocabulary GOAL_BY_KIND keys on, so a caller whose own envelope.parsed never
+ *  stood (this force's whole reason to exist — see relationTermOf/
+ *  isVagueRelationTouch's own docs) can still deduce the correct "Goal (inferred):
+ *  …" line instead of silently carrying forward a null goal from earlier in the
+ *  turn. */
 async function relationForceAnswer(query, envelope, { graph, config, source, templates }) {
   const rawTerm = relationTermOf(query, envelope);
   if (!rawTerm) return null;
@@ -3308,8 +3314,9 @@ async function relationForceAnswer(query, envelope, { graph, config, source, tem
   try { ({ composeRelation, RELATION_TERM } = await import("./concept.mjs")); }
   catch { return null; }
   const term = String(rawTerm).toLowerCase();
-  if (!RELATION_TERM[term]) return null; // not an enumerable edge concept — ordinary path owns it
-  const definition = (await relationDefinitions()).get(RELATION_TERM[term]) ?? null;
+  const kind = RELATION_TERM[term];
+  if (!kind) return null; // not an enumerable edge concept — ordinary path owns it
+  const definition = (await relationDefinitions()).get(kind) ?? null;
   if (!definition) return null;
   // Same graph-load fallback as conceptForceAnswer: the shell hands the loaded graph
   // straight in; the pure runTurn(config) path loads it the way dispatchTool does.
@@ -3329,7 +3336,7 @@ async function relationForceAnswer(query, envelope, { graph, config, source, tem
   const pending = composed.remainder && composed.remainder.length
     ? { items: composed.remainder, noun: composed.noun }
     : null;
-  return { text, pending };
+  return { text, pending, kind };
 }
 
 /** THE CONCEPT FORCE — compose the three-band answer (corpus/seon definition + real
@@ -3571,7 +3578,23 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // SAME value the debug trace's own "goal:" line uses (one deduction, two
   // presentations) — null here (no parse stood at all) means withGoalLine
   // shows nothing, never a "Goal (inferred): unclear" line.
-  const deduced = deduceGoalFromParsed(envelope?.parsed);
+  // `let`, not `const`: the RELATION CONCEPT FORCE (relationForceAnswer, below)
+  // can answer a turn CORRECTLY with no envelope.parsed at all to deduce from —
+  // a staccato relation-chain continuation whose leading connective never
+  // itself parses ("and inherits?": ask()'s raw grammar has no production for
+  // a bare relation word with no verb, exactly like the "cochange" vague-touch
+  // gap composeRelation's own degrade fix addressed) still reaches the SAME
+  // relation force a normally-parsed "what about inherits" would. Tier-2
+  // playtest cycle 9, the Goal-line gap cycle 8 flagged: the answer content
+  // was always correct here — only the cosmetic trailing "Goal (inferred): …"
+  // line went missing, because it was computed once, this early, straight off
+  // envelope.parsed and never revisited even when a LATER lane went on to
+  // answer the turn through a completely different path. Reassigned at the
+  // relation-force call site below (never overwritten with something worse:
+  // only filled in from the SAME GOAL_BY_KIND table deduceGoalFromParsed
+  // itself already uses for a normally-parsed relation query, so the two
+  // never disagree on the cases where both would fire).
+  let deduced = deduceGoalFromParsed(envelope?.parsed);
   note(trace, `goal: ${deduced ?? "unclear — the phrasing didn't resolve to a known query shape"}`);
   // MISS handling. The intent lanes + short-miss are RECOGNIZER-gated on the query
   // text AND only consulted on a would-miss, so a real graph query — a hit, an honest
@@ -3800,6 +3823,19 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         conceptPending = relation.pending;
         note(trace, "lane: THE RELATION CONCEPT FORCE — the touched word named a known, edge-bearing relation kind");
         note(trace, "source: relationForceAnswer over the loaded graph's own edges (not corpus)");
+        // Goal-line gap fix (Tier-2 playtest cycle 9): this force just answered
+        // the turn CORRECTLY over a query shape ask()'s own grammar may never
+        // have parsed at all (a staccato relation-chain continuation whose
+        // leading connective never itself parses, "and inherits?") — `deduced`
+        // was computed way above, off envelope.parsed alone, and would
+        // otherwise stay null forever here even though the answer is real.
+        // relation.kind is the SAME GOAL_BY_KIND vocabulary a normally-parsed
+        // relation query already deduces its goal line from, so this can never
+        // disagree with the ordinary path on a case where both would fire.
+        if (relation.kind && GOAL_BY_KIND[relation.kind]) {
+          deduced = GOAL_BY_KIND[relation.kind];
+          note(trace, `goal: ${deduced} (revised — the relation concept force answered where the raw parse never stood)`);
+        }
       }
     }
   }

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