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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.0.4",
+  "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));
@@ -930,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;
@@ -1005,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) {
@@ -1026,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;
@@ -1861,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);
@@ -1890,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)`);
+        }
       }
     }
   }