@polycode-projects/the-mechanical-code-talker 1.10.3 → 1.10.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.10.3",
+  "version": "1.10.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/chat.mjs

@@ -4121,15 +4121,16 @@ const KNOW_ABOUT_RE = /^(?:what\s+do\s+you\s+know\s+about|what(?:'s|s|\s+is)\s+i
 /** How many facts a single answer lists before the remainder is paged with "more". */
 const FACT_ANSWER_CAP = 32;
 
-/** Four sibling readers closing the gap left
+/** Five sibling readers closing the gap left
  *  by ISA_ASK_RE's own family: forward yes/no and reverse-by-object shapes for
  *  `mgx:capableOf`, `mgx:hasA`, and the ISA-family predicates. None of these
- *  four leads ("can"/"could", "what can … do", "what has", "what inherit(s)")
+ *  five leads ("can"/"could", "does/do … have", "what can … do", "what has", "what inherit(s)")
  *  overlaps KNOW_ABOUT_RE's fixed leads above, or RELATION_FACT_YESNO_RE/
  *  RELATION_WHO_ASK_RE's required leading "is/are/was/were" (those two live in
  *  the separate factReadBack, only ever reached via `factAnswer(...) ??
  *  factReadBack(...)` — never both). */
 const CAN_ASK_RE = /^(?:can|could)\s+(?:an?\s+)?([\w'-]+(?:\s+[\w'-]+)*?)\s+([a-z]+)[?.!\s]*$/i;
+const DOES_HAVE_ASK_RE = /^(?:does|do)\s+(?:an?\s+|the\s+)?(.+?)\s+have\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i;
 const WHAT_CAN_DO_RE = /^what\s+can\s+(?:an?\s+)?(.+?)\s+do[?.!\s]*$/i;
 const WHAT_HAS_RE = /^what\s+has\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
 // "what is used for riding" / "what can be used for riding" / "what is for
@@ -4349,6 +4350,22 @@ export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle
     return null;
   }
 
+  // (b2b) "does a dog have a tail" — yes iff a remembered mgx:hasA fact says
+  // so: the forward yes/no mirror of WHAT_HAS_RE below, with the same
+  // single-hit lookup and "never a guessed no" discipline as CAN_ASK_RE
+  // above. Only diverts on a REAL hit, so a code-shaped "does app.mjs have
+  // tests" (no hasA fact) keeps whatever miss text already stands.
+  const doesHave = q.match(DOES_HAVE_ASK_RE);
+  if (doesHave) {
+    const subj = factTermVariants(normFactTerm, doesHave[1]);
+    const obj = factTermVariants(normFactTerm, doesHave[2]);
+    const hit = (await memoryFacts(memoryDir)).find(
+      (f) => f.predicate === "mgx:hasA" && subj.has(f.subject) && obj.has(f.object),
+    );
+    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    return null;
+  }
+
   // (b3) "what can a dog do" — every remembered mgx:capableOf fact for the
   // subject, open-list. Reuses the meta-lane's subject-hits/rank/render/
   // paginate recipe (lane (a) above) verbatim, with the predicate hardcoded.
@@ -5486,7 +5503,42 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
         }
       }
     }
-    return null; // no remembered fact — the honest miss stands (never a guessed "no")
+    // Every yes-chase and the disjoint "no" above missed. The old
+    // unconditional decline here fell through to the structural "couldn't
+    // parse this as a graph question" wall — actively misleading for a KNOWN
+    // subject, twice over: the question DID parse, and the wall's hint
+    // suggests the exact shape the user just typed. When the subject has
+    // remembered isa-family facts, answer with an honest, specific miss that
+    // cites what IS remembered instead. An unknown subject still declines to
+    // the standing wall/teach-hint path — and this never guesses a "no".
+    // The SUBJECT'S OWN variants only — subjCandidates was augmented above
+    // with the graph entity's class noun (the CLASS↔INSTANCE bridge), and
+    // filtering on it here would cite facts about that noun ("class ⊑
+    // component") as if they were facts about the asked subject ("Widget").
+    const directSubjVariants = factTermVariants(normFactTerm, isaAsk[1]);
+    const knownSubjectIsa = isa.filter((f) => directSubjVariants.has(f.subject)).sort(byTrust);
+    const subjectWord = isaAsk[1].trim();
+    const kindWord = stripTrailingDiscourseTag(isaAsk[2]).trim();
+    if (knownSubjectIsa.length) {
+      const shown = knownSubjectIsa.slice(0, 3).map(renderFactLine).join("; ");
+      return {
+        text: `I can't confirm that — nothing I remember says ${subjectWord} is a ${kindWord}. I do know: ${shown}. If it's true, teach me: "${subjectWord} is a kind of ${kindWord}".`,
+        replace: true,
+        miss: true, // still a MISS in the turn record — honest wording, not an answer
+      };
+    }
+    // Subject with NO isa facts: only divert when it's mentioned NOWHERE at
+    // all (no fact row on either side, no code entity by id OR class noun) —
+    // a subject known via OTHER predicates ("ahab is male") or the code graph
+    // keeps the old decline, so nothing downstream is ever shadowed.
+    if (!ent && !noun && !rows.some((f) => subjCandidates.has(f.subject) || subjCandidates.has(f.object))) {
+      return {
+        text: `I can't confirm that — I don't know "${subjectWord}" at all yet. If it's true, teach me: "${subjectWord} is a kind of ${kindWord}".`,
+        replace: true,
+        miss: true,
+      };
+    }
+    return null; // the honest miss stands (never a guessed "no")
   }
 
   // (a1c-i) CARDINALITY MONOTONICITY — "does every X have at least N Y" over
@@ -7088,6 +7140,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     if (memoryDir) {
       bareMetaHit = (await factAnswer(memoryDir, gateQuery, envelope, miss, biasByBundle, cache))
         ?? (await factReadBack(memoryDir, gateQuery, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
+      if (bareMetaHit?.miss) bareMetaHit = null; // an honest-miss return never diverts the gate
       // A bare "what is X" with NO taught fact but a KNOWN curated corpus term
       // ("what is cache", no article) needs the same "only diverts on a REAL
       // hit" treatment — curatedDefinitionAnswer otherwise only ever runs once
@@ -7158,8 +7211,14 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
     if (fact) {
       answer = fact.replace ? fact.text : `${answer}\n${fact.text}`;
-      via = "fact";
-      recordMiss = false;
+      // A fact-lane return flagged `miss` is an HONEST MISS in better words
+      // (the isa ladder's "I can't confirm that" closers) — the turn record
+      // keeps miss=true and via stays untouched, so miss-rate metrics and
+      // recall's own miss-gated lanes see it exactly like the wall it replaced.
+      if (!fact.miss) {
+        via = "fact";
+        recordMiss = false;
+      }
       if (fact.pending) factPending = fact.pending; // a truncated fact list → paginable remainder
       if (typeof fact.trust === "number") entailedTrust = fact.trust; // live-chase trust (see the `entailedTrust` declaration above)
       note(trace, `lane: (3) memory facts — factAnswer/factReadBack matched (memoryDir=${memoryDir})`);