@polycode-projects/the-mechanical-code-talker 1.10.7 → 1.10.10

package/package.json

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

@@ -4166,6 +4166,42 @@ const REVERSE_PREDICATE_MARKERS = Object.entries(FACT_PREDICATE_PHRASES)
     re: new RegExp(`^what\\s+${escapeRegex(phrase)}\\s+(.+?)[?.!\\s]*$`, "i"),
   }))
   .sort((a, b) => b.re.source.length - a.re.source.length); // longest phrase first
+
+// The FORWARD yes/no mirror of REVERSE_PREDICATE_MARKERS: one derived
+// "is/are X <phrase> Y" (copula phrases), "can X be Y" (receivesAction), or
+// "does/do X <base-verb> Y" (verb phrases, naive de-3sg fold) reader per
+// FACT_PREDICATE_PHRASES entry — so every relation the table can RENDER can
+// also be ASKED as a forward yes/no, instead of each one needing its own
+// hand-written lane. Excluded: the isa family and hasProperty (ISA_ASK_RE /
+// IS_ADJECTIVE_YESNO_RE territory), hasA and capableOf (their dedicated
+// readers above carry teach hints these derived ones deliberately don't —
+// no derived hint is emitted because no teach phrasing for these relations
+// is verified to round-trip).
+const FORWARD_YESNO_EXCLUDE = new Set([
+  "rdfs:subClassOf", "rdf:type", "owl:disjointWith", "mgx:hasProperty",
+  "mgx:hasA", "mgx:capableOf",
+  // ownership's dedicated reader (OWNS_YESNO_RE) answers a confident
+  // closed-world "no" — a stronger contract than the derived "can't
+  // confirm", so the derived reader must never intercept it.
+  "mgx:ownedBy",
+]);
+const FORWARD_YESNO_MARKERS = Object.entries(FACT_PREDICATE_PHRASES)
+  .filter(([predicate]) => !FORWARD_YESNO_EXCLUDE.has(predicate))
+  .map(([predicate, phrase]) => {
+    let re;
+    if (phrase === "can be") {
+      re = new RegExp("^can\\s+(?:an?\\s+|the\\s+)?(.+?)\\s+be\\s+(.+?)[?.!\\s]*$", "i");
+    } else if (phrase.startsWith("is ")) {
+      const rest = escapeRegex(phrase.slice(3));
+      re = new RegExp(`^(?:is|are)\\s+(?:an?\\s+|the\\s+)?(.+?)\\s+${rest}\\s+(?:an?\\s+|the\\s+)?(.+?)[?.!\\s]*$`, "i");
+    } else {
+      const [head, ...tail] = phrase.split(" ");
+      const base = [head.replace(/s$/, ""), ...tail].map(escapeRegex).join("\\s+");
+      re = new RegExp(`^(?:does|do)\\s+(?:an?\\s+|the\\s+)?(.+?)\\s+${base}\\s+(?:an?\\s+|the\\s+)?(.+?)[?.!\\s]*$`, "i");
+    }
+    return { predicate, phrase, re };
+  })
+  .sort((a, b) => b.re.source.length - a.re.source.length); // longest phrase first
 // On the FIRST turn of a graph-less session, `envelope` stays null for the
 // whole turn (dispatchTool's loadGraph() throws its own documented empty-graph
 // ToolError, self-correcting from turn 2 on), so this regex is the ONLY path
@@ -4330,6 +4366,42 @@ export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle
   }
   if (!miss) return null;
 
+  // (b0) Derived forward yes/no readers — FORWARD_YESNO_MARKERS, one per
+  // renderable relation. Runs BEFORE the isa lane because ISA_ASK_RE's lazy
+  // subject otherwise swallows these shapes whole ("is a wheel part of a
+  // car" reads as subject "wheel part of") and ends the cascade. A real fact
+  // answers yes; a subject known under the SAME relation gets an honest miss
+  // citing those facts; a subject known at all (with no structural parse
+  // standing) gets a bare honest miss; anything else leaves the standing
+  // miss text alone — so a code-shaped query with a real parse is never
+  // hijacked.
+  for (const { predicate, phrase, re } of FORWARD_YESNO_MARKERS) {
+    const m = q.match(re);
+    if (!m) continue;
+    const facts = await memoryFacts(memoryDir);
+    const subj = factTermVariants(normFactTerm, m[1]);
+    const obj = factTermVariants(normFactTerm, m[2]);
+    const hit = facts.find((f) => f.predicate === predicate && subj.has(f.subject) && obj.has(f.object));
+    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    const sameRelation = facts.filter((f) => f.predicate === predicate && subj.has(f.subject));
+    if (sameRelation.length) {
+      const shown = sameRelation.slice(0, 3).map(renderFactLine).join("; ");
+      return {
+        text: `I can't confirm that — nothing I remember says ${m[1]} ${phrase} ${m[2]}. I do know: ${shown}.`,
+        replace: true,
+        miss: true,
+      };
+    }
+    if (!envelope?.parsed && facts.some((f) => subj.has(f.subject))) {
+      return {
+        text: `I can't confirm that — nothing I remember says ${m[1]} ${phrase} ${m[2]}.`,
+        replace: true,
+        miss: true,
+      };
+    }
+    break; // shape matched, nothing honest to add — the standing miss stands
+  }
+
   // (b) "is a module a component" — yes iff a remembered isa-family fact says so.
   // Also accepts "why is X a Y" / "explain how you know X is Y" — see matchWhyIsa.
   const isa = q.match(ISA_ASK_RE) || matchWhyIsa(q);
@@ -5591,7 +5663,8 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
     // 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))) {
+    if (!ent && !noun && !isPronoun(subjectWord)
+      && !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,
@@ -6878,7 +6951,7 @@ async function entityOfKindInText(graph, expectedClass, answerText) {
  *  otherwise the unchanged dispatchTool path (which also yields the no-graph error).
  *  A hit updates the focus to the resolved object. Grammar miss / ToolError → a
  *  normal answer, never a crash. */
-async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null }) {
+async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null }) {
   const ts = new Date().toISOString();
   // DISCOURSE ANAPHORA: a follow-up like "which of those are tested" / "count
   // them" filters or counts the PREVIOUS answer's entity set, threaded as
@@ -7166,7 +7239,13 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     }
   }
   const conversationalCandidateBaseGate = !handled && miss && !envelope?.parsed && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus;
-  const isConversationalCandidate = conversationalCandidateBaseGate && isConversational(query);
+  // A turn whose pronoun was bound to a vocabulary antecedent is PROVABLY a
+  // fact question ("can it bark" → "can dog bark") — never conversational,
+  // however short. Without this, the substituted 3-worder still trips
+  // isConversational's word-count catch-all into the orientation blurb, and
+  // that blurb (a dispatched turn) then becomes `last`, wiping the very
+  // antecedent the next pronoun turn needs.
+  const isConversationalCandidate = conversationalCandidateBaseGate && !vocabAntecedent && isConversational(query);
   // "what is X" with NO article ("what is john") is BOTH conversational-shaped
   // (isConversational() would claim it) AND a legitimate bare meta/fact-lookup
   // form (BARE_WHATIS_RE). Diverts ONLY when a REAL fact actually resolves for
@@ -8041,6 +8120,21 @@ function rewriteUsesAsBaseFrame(text) {
   return null;
 }
 
+/** The subject of the LAST turn's first fact line, for vocabulary pronoun
+ *  binding ("what is a dog" → "can it bark"). Fact answers render rigidly —
+ *  "<subject> <phrase> <object> (source: …)", optionally behind a "yes — "/
+ *  "no — "/"you told me: " prefix — so a 1–2 word leading subject followed
+ *  by a phrase-table verb is extractable without any NLP. Anything else
+ *  (code answers, walls, conversational text) returns null and no
+ *  substitution happens. */
+function vocabAntecedentFrom(last) {
+  const first = String(last?.answer || "").split("\n")[0]
+    .replace(/^(?:yes|no) — /i, "")
+    .replace(/^you told me: /i, "");
+  const m = first.match(/^([a-z][\w'-]*(?:\s+[a-z][\w'-]*)?)\s+(?:is|are|has|can|causes|wants|requires|involves|means|begins|ends)\b/i);
+  return m ? m[1] : null;
+}
+
 export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null } = {}) {
   const line = String(input ?? "").trim();
   // ONE fresh, empty cache for this turn only — every factRows() reader
@@ -8058,13 +8152,32 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // before ANY dispatch lane sees the text. Null (no-op) for every turn that
   // doesn't match one of the four discontiguous shapes.
   const baseFrameRewrite = rewriteUsesAsBaseFrame(preRewriteLine);
-  const workingLine = baseFrameRewrite || preRewriteLine;
+  const frameLine = baseFrameRewrite || preRewriteLine;
+  // VOCABULARY pronoun antecedent — "what is a dog" then "can it bark". The
+  // code-graph focus mechanism only ever binds {id,label} GRAPH entities, so
+  // in a vocabulary conversation "it" resolved to nothing and the question
+  // fell to the conversational gate or a garbage-subject fact lookup.
+  // Substituted here, once, before any dispatch lane sees the text — and
+  // ONLY when no code focus is standing (a graph session's own pronoun
+  // resolution is untouched), the turn looks like a fact question, and the
+  // LAST answer's own first fact line names a subject to bind to.
+  // Anchored to SUBJECT position only: the pronoun must directly follow the
+  // opening auxiliary ("can it bark") or "what is/are" WITH a continuation
+  // ("what is it used for") — so idioms carrying a trailing dummy pronoun
+  // ("what time is it") and the bare "what is it" are never rewritten.
+  const pronounLead = frameLine.match(/^((?:is|are|can|could|does|do)\s+|what\s+(?:is|are)\s+)(?:it|they)\b(\s+\S.*)?$/i);
+  const vocabAntecedent = (!focus?.id && memoryDir && pronounLead
+    && !(/^what/i.test(pronounLead[1]) && !pronounLead[2]))
+    ? vocabAntecedentFrom(last) : null;
+  const workingLine = vocabAntecedent
+    ? `${pronounLead[1]}${vocabAntecedent}${pronounLead[2] || ""}`
+    : frameLine;
   const templates = await chatTemplates(); // failure-tolerated: null degrades, never throws
   const trace = narrate ? [] : null;
   // vocabHint: createSession computes this ONCE per session; a direct
   // runTurn() caller that doesn't pass one gets it computed here instead.
   const resolvedVocabHint = vocabHint ?? vocabExampleHint(await hasSeededVocabulary(memoryDir));
-  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache };
+  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent };
   // A DISPATCHED turn (count / slash-command / ask) becomes the new "last
   // answer" that why/say-more re-renders; a conversational turn does not.
   // Every dispatched turn's result passes through finish() here — the LAST
@@ -8077,7 +8190,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     // indirect-request wrapper stripped and/or the discontiguous-frame
     // rewrite applied) — restore the ORIGINAL raw `line` into record.query
     // and the logged transcript echo here, once, centrally.
-    if (indirectMatch || baseFrameRewrite) {
+    if (indirectMatch || baseFrameRewrite || vocabAntecedent) {
       if (finished.record) finished.record.query = line;
       if (Array.isArray(finished.logLines) && finished.logLines.length > 1) finished.logLines[1] = `> ${line}`;
     }
@@ -8102,7 +8215,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // resolve no entity and carry their own preserved `last`. Bypasses withLast (a
   // conversational turn is never finish()'d / never becomes a new `last`), so the
   // narrate block is applied directly here instead.
-  const convo = conversationalTurn(workingLine, ctx);
+  const convo = vocabAntecedent ? null : conversationalTurn(workingLine, ctx);
   if (convo) return withNarration(convo, trace, "casual/social — no graph intent");
 
   // "more" — page the remainder of a previous long listing, if one is held. Gated on