@polycode-projects/the-mechanical-code-talker 1.10.8 → 1.10.11

package/package.json

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

@@ -1532,7 +1532,7 @@ const WALL_MISS_ANYWHERE_RE = /couldn't parse this as a graph question\. Try:/;
 // assert/memory path; when it can't be stored, say what CAN be remembered
 // instead of the grammar wall or a silent data loss.
 const TEACH_RE = /^(?:please\s+)?(?:i\s+(?:want|wanted)\s+you\s+to\s+|i(?:'d|\s+would)\s+like\s+you\s+to\s+)?(?:remember|note|keep in mind|jot down|for the record|fyi|learn)\b(?:\s+(?:this|that|also))?[:,]?\s*(?:that\s+)?(.+?)[.?!]*$/i;
-const BARE_DECLARATIVE_RE = /^(?:every |each |all |a |an )?[\w-]+ (?:is|are) (?:a |an )?[\w-]+$/i;
+const BARE_DECLARATIVE_RE = /^(?:every |each |all |a |an )?[\w-]+(?: [\w-]+)? (?:is|are) (?:a |an )?[\w-]+$/i;
 /** Interrogative / auxiliary leads that make an "X is a Y"-shaped line a QUESTION
  *  ("what is a cache", "is a module a component"), never a teach declarative. */
 const QUESTION_LEAD_RE = /^(?:what|who|which|where|when|why|how|is|are|do|does|did|can|could|should|would|will|has|have)\b/i;
@@ -5663,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,
@@ -6950,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
@@ -7238,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
@@ -8113,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
@@ -8130,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
@@ -8149,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}`;
     }
@@ -8174,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

package/src/grammar/ace.mjs

@@ -95,7 +95,7 @@ const stripDet = (tokens) =>
  *  with "a"/"an" — the one signal that a singular-plural-fold collision
  *  (die/dice, person/people, tooth/teeth) can be resolved by, rather than
  *  silently committing to whichever the lexicon happens to fold to first. */
-function resolveNP(lexicon, tokensIn) {
+function resolveNP(lexicon, tokensIn, { allowCompound = false } = {}) {
   const ns = lexicon.ns;
   const singularOnly = tokensIn.length > 1 && SINGULAR_ONLY_DET.has(tokensIn[0].toLowerCase());
   const tokens = stripDet(tokensIn);
@@ -131,6 +131,26 @@ function resolveNP(lexicon, tokensIn) {
       }
       return { term, individual: false, noun, extras, unknown: [] };
     }
+    // Two plain NOUNS in a row are ONE compound noun ("guinea pig", "sports
+    // car"), space-joined to match the corpus's own multi-word concepts
+    // ("schema person"), so the taught fact and the query side unify.
+    // STRICTLY OPT-IN per call site (allowCompound): only the patterns where
+    // a compound subject is safe request it — capability, quantified
+    // membership, disjointness, and the articled-complement copula. The
+    // generic relation walk and the bare-adjective copula never do, so a
+    // question lead ("does dog have…") or a property sentence ("checkout
+    // flow is deprecated") can never silently become an ACE teach. A
+    // DECLARED proper name in either slot ("GitLab pipeline") keeps the
+    // structural miss below — a name in the wrong slot, not a compound.
+    if (allowCompound
+      && !lookupProperName(lexicon, tokens[0]) && !lookupProperName(lexicon, tokens[1])
+      && /^[a-z][a-z'-]*$/i.test(tokens[0]) && /^[a-z][a-z'-]*$/i.test(tokens[1])) {
+      const n0 = lookupNoun(lexicon, tokens[0], { singularOnly: false });
+      const n1 = lookupNoun(lexicon, tokens[1], { singularOnly });
+      if (n0 && n1) {
+        return { term: `${ns}${tokens[0].toLowerCase()} ${tokens[1].toLowerCase()}`, individual: false, noun: n1, extras: [], unknown: [] };
+      }
+    }
     // only genuinely undeclared words are residue — a declared word in the
     // wrong slot ("GitLab pipeline") is a structural miss, not an unknown
     const unknown = tokens.filter((t) => !classify(t, lexicon));
@@ -326,13 +346,11 @@ function parseEvery(lexicon, toks, lower) {
   }
   const isIdx = lower.indexOf("is");
   if (isIdx <= 1 || isIdx === toks.length - 1) return null;
-  const np1 = resolveNP(lexicon, toks.slice(1, isIdx));
   const rest = toks.slice(isIdx + 1);
-  if (rest.length === 1) {
-    const adj = lookupAdjective(lexicon, rest[0]);
-    if (adj) return adjectiveCopula(lexicon, PATTERN_ADJECTIVE, np1, adj);
-  }
-  const np2 = resolveNP(lexicon, rest);
+  const everyAdjOnly = rest.length === 1 ? lookupAdjective(lexicon, rest[0]) : null;
+  const np1 = resolveNP(lexicon, toks.slice(1, isIdx), { allowCompound: !everyAdjOnly });
+  if (everyAdjOnly) return adjectiveCopula(lexicon, PATTERN_ADJECTIVE, np1, everyAdjOnly);
+  const np2 = resolveNP(lexicon, rest, { allowCompound: true });
   if (np1.term == null || np2.term == null) return missOrNull(PATTERN_SUB_CLASS_OF, [np1, np2]);
   if (np1.individual || np2.individual) return null; // "every X is chat.mjs" — not the fragment
   return hit(PATTERN_SUB_CLASS_OF, [np1, np2], [
@@ -344,8 +362,8 @@ function parseEvery(lexicon, toks, lower) {
 function parseDisjoint(lexicon, toks, lower) {
   const isIdx = lower.indexOf("is");
   if (isIdx <= 1 || isIdx === toks.length - 1) return null;
-  const np1 = resolveNP(lexicon, toks.slice(1, isIdx));
-  const np2 = resolveNP(lexicon, toks.slice(isIdx + 1));
+  const np1 = resolveNP(lexicon, toks.slice(1, isIdx), { allowCompound: true });
+  const np2 = resolveNP(lexicon, toks.slice(isIdx + 1), { allowCompound: true });
   if (np1.term == null || np2.term == null) return missOrNull(PATTERN_DISJOINT_WITH, [np1, np2]);
   if (np1.individual || np2.individual) return null;
   return hit(PATTERN_DISJOINT_WITH, [np1, np2], [
@@ -393,14 +411,14 @@ function parseOfForm(lexicon, toks, lower) {
 
 /** Patterns 2 (class assertion), 1's bare-copula variant, and 8's copula arm. */
 function parseCopula(lexicon, toks, lower, isIdx) {
-  const np1 = resolveNP(lexicon, toks.slice(0, isIdx));
   const rest = toks.slice(isIdx + 1);
   if (!rest.length) return null;
+  const np1 = resolveNP(lexicon, toks.slice(0, isIdx), { allowCompound: rest.length > 1 });
   if (rest.length === 1) {
     const adj = lookupAdjective(lexicon, rest[0]);
     if (adj) return adjectiveCopula(lexicon, PATTERN_ADJECTIVE, np1, adj);
   }
-  const np2 = resolveNP(lexicon, rest);
+  const np2 = resolveNP(lexicon, rest, { allowCompound: true });
   if (np1.term == null || np2.term == null) {
     return missOrNull(np1.individual ? PATTERN_TYPE_ASSERTION : PATTERN_SUB_CLASS_OF, [np1, np2]);
   }
@@ -448,7 +466,7 @@ export function parseAce(sentence, lexicon = loadLexicon()) {
  *  has no negative-capability predicate, and a silently dropped negation
  *  would invert the taught meaning. */
 function parseCapability(lexicon, toks, canIdx) {
-  const np1 = resolveNP(lexicon, toks.slice(0, canIdx));
+  const np1 = resolveNP(lexicon, toks.slice(0, canIdx), { allowCompound: true });
   if (np1.term == null) return null;
   // The capability's object is a VERB ("swim"), not a lexicon noun, so
   // resolveNP is the wrong resolver for it: accept exactly one bare word,