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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "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));
@@ -311,7 +319,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 +589,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,
@@ -863,7 +938,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;
@@ -938,9 +1014,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) {
@@ -959,7 +1046,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;
@@ -1479,10 +1567,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);
@@ -1532,6 +1652,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: [] };
@@ -1738,15 +1882,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);
@@ -1767,12 +1962,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) {

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)`);
+        }
       }
     }
   }