@polycode-projects/the-mechanical-code-talker 1.8.15 → 1.8.17

package/package.json

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

@@ -644,6 +644,15 @@ export const FILLER_WORDS = Object.freeze([
   "please", "could you", "can you", "would you", "tell me", "i wonder",
   "just wondering", "quickly", "real quick", "kinda", "sorta",
   "btw", "by the way", "you",
+  // "quick q" (BENCHMARK_CONVERSATION_1.8.14.md item 11): the casual abbreviated
+  // sibling of GREETING_PREAMBLE_RE's own "quick question" clause (normalize.mjs)
+  // — that frame requires a delimiter immediately after the greeting word
+  // ("hey, quick question - …"), so it never matches "hey quick q, …" (no
+  // delimiter between "hey" and "quick q"). Filler-stripping instead — this
+  // list is matched word-boundary-anywhere, not anchored — closes the gap
+  // without needing GREETING_PREAMBLE_RE's own stricter delimiter-position
+  // shape.
+  "quick q",
 ]);
 
 /** Deictic/pronoun terms that refer to a context entity rather than naming one

package/src/ask.mjs

@@ -3196,7 +3196,23 @@ export function traverse(graph, parsed, { contextId = null, prev = null, pinnedO
   if (shape === "ask") {
     const subj = resolveTermOrContext(graph, parsed.subject, contextId);
     const obj = resolveTermOrContext(graph, parsed.object, contextId);
-    if (!subj.match || !obj.match) {
+    // BENCHMARK_CONVERSATION_1.8.14.md item 7(b): a term that resolved only via a
+    // TIED, ambiguous fuzzy/prose match (e.g. a garbled object phrase like "handler
+    // I think" — trailing hedge noise a plain declarative leaked into the object
+    // slot) used to fall straight through as if `obj`/`subj` were a confident
+    // single match, so a randomly-first-picked TIED candidate (once, live, a raw
+    // Commit whose "label" IS its short hash, "c3d4e5f6a1b2") rode straight into
+    // the Yes/No render's "No — no <kind> edge found from A to B" sentence — an
+    // internal id leaking into user-facing text off the back of an unresolved tie,
+    // not a real resolution. Every OTHER shape in this file already declines
+    // rather than guessing on a tie (resolveObject's own "never a guess" contract,
+    // its docblock above); this shape is the one place that never checked the
+    // `ambiguous` flag its own resolver already computed. Declining here (leaving
+    // subjMatch unset, same as the `!subj.match || !obj.match` miss just below)
+    // reaches the SAME "couldn't resolve one of the terms in this question" honest
+    // miss render() already uses — never a confident wrong answer, and never a
+    // raw internal id surfacing off a coin-flip pick among tied candidates.
+    if (!subj.match || !obj.match || subj.ambiguous || obj.ambiguous) {
       return {
         matches: [], objMatch: obj.match, candidates: obj.candidates, traversal: null, ambiguous: false, answer: null,
         unresolvedPronoun: !!(subj.unresolvedPronoun || obj.unresolvedPronoun),

package/src/chat.mjs

@@ -813,6 +813,13 @@ const CAPABILITY_PHRASES = [
   // and fall to the raw grammar wall instead of orientationAnswer — the same
   // question in every way that matters, just phrased with emphasis.
   /^(?:so,?\s+)?what can (?:you|u)(?:\s+(?:actually|really))? do\??$/i, /^(?:so,?\s+)?what do you(?:\s+(?:actually|really))? do\??$/i,
+  // BENCHMARK_CONVERSATION_1.8.14.md item 12 (pure-small-talk persona): "what
+  // can you actually help with" — the natural pivot from small talk into a
+  // capability question — used to miss every entry above, since none of them
+  // accept "help (me)? with" as a synonym tail for "do" (only bare "help" /
+  // "help me" without an object, the entry just below, was covered). Same
+  // "so,"/"actually"/"really" optional lead-in as the "do" pair above.
+  /^(?:so,?\s+)?what can (?:you|u)(?:\s+(?:actually|really))? help(?:\s+me)?\s+with\??$/i,
   /^help( me)?\??$/i, /^\?+$/,
   /^how do (i|you) work\??$/i, /^how does (this|it) work\??$/i,
   // unix-habit openers typed inside the REPL out of muscle memory — argv-only
@@ -938,6 +945,20 @@ const FEELINGS_PHRASES = [
   /^are you (?:sentient|conscious|self[- ]aware)\??$/i,
   /^can you feel(?:\s+(?:things|emotions|anything))?\??$/i,
   /^do you (?:feel|think|dream)\??$/i,
+  // BENCHMARK_CONVERSATION_1.8.14.md item 12 (pure-small-talk persona): direct
+  // personal questions ("how are you doing today", "what's your favorite
+  // color", "do you get bored") — the SAME family this closed set already
+  // exists for (a personal-life question about tmct, not a code-graph query)
+  // — mostly fell through to the bare grammar wall instead of this honest,
+  // on-brand decline, because none of them happened to match the four
+  // narrower entries above. Additive, same discipline as CAPABILITY_PHRASES'
+  // own "keeps growing as new natural phrasings surface" precedent.
+  /^how (?:are|r) (?:you|u) doing(?:\s+today)?\??$/i,
+  /^what(?:'s|s|\s+is) your (?:favou?rite\s+(?:colou?r|food|movie|book|band|song|number)|name)\??$/i,
+  /^do you (?:get|ever get) bored\??$/i,
+  /^what do you do for fun\??$/i,
+  /^can you (?:tell|make)\s+(?:me\s+)?(?:a\s+)?jokes?\??$/i,
+  /^do you (?:know|know anything|know much)\s+about\s+(?:movies?|sports?|music|tv|television)(?:\s+or\s+(?:movies?|sports?|music|tv|television))?\??$/i,
 ];
 /** The structural verbs/nouns that mark a near-miss code question (→ keep the
  *  precise grammar hint, not the friendly nudge). */
@@ -1687,6 +1708,14 @@ const BARE_DECLARATIVE_RE = /^(?:every |each |all |a |an )?[\w-]+ (?:is|are) (?:
 /** 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;
+/** A plain declarative "X is a kind of Y" / "X is a Y" shape (subject-first, no
+ *  question lead — paired with QUESTION_LEAD_RE at every call site), tolerating
+ *  an infix "kind of"/"type of" (teachLane's own stripKindOf handles this same
+ *  infix ahead of its narrower recognizers — this is a cheap TRIGGER check only,
+ *  not a storage decision). Used by runAsk's relaxedTeachCollision guard (below)
+ *  to recognize when a query the ask engine "answered" via relaxation was
+ *  actually a teach-shaped sentence, not a real question. */
+const DECLARATIVE_KIND_OF_RE = /^(?:every\s+|each\s+|all\s+|a\s+|an\s+)?[\w-]+(?:\s+[\w-]+)?\s+(?:is|are)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?[\w-]+[.!]*$/i;
 /** A bare wh-word token, tested one word at a time against `hasMidSentenceInterrogative`'s
  *  own tokenization below — never re-anchored, so it matches at ANY word position. */
 const MID_SENTENCE_WH_RE = /^(?:which|who|what|where|when|why|how)$/i;
@@ -1977,23 +2006,33 @@ function singularizeSurface(word) {
 const SOME_A_FEW_RE = /^(some|a few)\s+([\w-]+)\s+are\s+([\w-]+)$/i;
 
 /** "(every|each|all|a|an )?X is/are (a|an )?Y" — the shape the unknown-subject
- *  fallback recognizes (group 2 = X, group 3 = Y); group 1 (when present)
+ *  fallback recognizes (group 2 = X, group 4 = Y); group 1 (when present)
  *  names the determiner, so the caller can tell a genuine "every" universal
  *  apart from a singular/specific-entity "a"/bare reading (only "every" gets a
  *  recorded quantifier here — this function's OWN caller passes it through to
  *  teachFact; assertTurn, below, records the same "every" quantifier
- *  independently for the pre-existing ACE-success path). Y (the object) is a
- *  single token, same as parseAce's own copula fragments; X (the subject) is
- *  ONE OR TWO tokens (Tier-5 playtest fix: "vulcan gizmo is a tool"/"remember
- *  vulcan gizmo is a tool" fell straight to a "teach me" nudge that offered
- *  THIS EXACT phrasing as the fix, then itself failed when tried — a
- *  single-token-only subject was too narrow for a natural 2-word noun phrase,
- *  the same class of gap OWNS_TEACH_RE's own object had before its own
- *  Tier-5 widening, above). The greedy quantifier tries the longer 2-word
- *  subject first, backtracking to 1 word only if the tail doesn't then start
- *  with is/are — the "is/are" anchor immediately after the subject removes
- *  the ambiguity a fully free-form multi-word subject would otherwise have. */
-const UNKNOWN_SUBJECT_RE = /^(every\s+|each\s+|all\s+|a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:is|are)\s+(?:an?\s+)?([\w-]+)$/i;
+ *  independently for the pre-existing ACE-success path). Group 3 is the
+ *  copula itself (is/are) — CAPTURED (not just matched) so a caller can tell
+ *  a genuinely PLURAL subject phrasing ("all men ARE mortal") apart from a
+ *  singular one ("redis IS a cache"): singularizing the subject before
+ *  storage is only ever correct for the former (see unknownSubjectFallback's
+ *  and unknownObjectFallback's own docblocks — this is the "men"->"man" fix's
+ *  own safety gate, added after singularizing unconditionally was found live
+ *  to corrupt the pre-existing "redis is a cache" pinned case: "redis", a
+ *  proper noun that happens to end in "s", naively strips to "redi" if
+ *  singularized on an "is" sentence, where no such fold was ever needed).
+ *  Y (the object) is a single token, same as parseAce's own copula fragments;
+ *  X (the subject) is ONE OR TWO tokens (Tier-5 playtest fix: "vulcan gizmo
+ *  is a tool"/"remember vulcan gizmo is a tool" fell straight to a "teach me"
+ *  nudge that offered THIS EXACT phrasing as the fix, then itself failed when
+ *  tried — a single-token-only subject was too narrow for a natural 2-word
+ *  noun phrase, the same class of gap OWNS_TEACH_RE's own object had before
+ *  its own Tier-5 widening, above). The greedy quantifier tries the longer
+ *  2-word subject first, backtracking to 1 word only if the tail doesn't then
+ *  start with is/are — the "is/are" anchor immediately after the subject
+ *  removes the ambiguity a fully free-form multi-word subject would
+ *  otherwise have. */
+const UNKNOWN_SUBJECT_RE = /^(every\s+|each\s+|all\s+|a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(is|are)\s+(?:an?\s+)?([\w-]+)$/i;
 
 /** ISA-family predicates (mirrors the private ISA_PREDICATES set defined near
  *  memoryFacts, below, at module scope — both are simple top-level consts
@@ -2092,7 +2131,7 @@ async function ungroundedPairHint(payload, lexicon, memoryDir) {
   if (!memoryDir) return "";
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return "";
-  const [, , subjectRaw, objectRaw] = m;
+  const [, , subjectRaw, , objectRaw] = m;
   const { loadLexicon } = await import("./grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
   if (await isGroundedTerm(subjectRaw, lex, memoryDir)) return "";
@@ -2144,12 +2183,29 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
-  const [, det, subjectRaw, objectRaw] = m;
+  const [, det, subjectRaw, verb, objectRaw] = m;
   const { loadLexicon, lookupNoun, lookupAdjective, classify } = await import("./grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
   // A known X's own ACE miss is a real miss — never silently reinterpreted here.
   if (classify(subjectRaw, lex)) return null;
   const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
+  // Singularize the SUBJECT before storage, but ONLY on a genuinely PLURAL
+  // phrasing ("all men ARE mortal", verb "are") — mirrors SOME_A_FEW_RE's own
+  // singularizeSurface() call (above), which is safe unconditionally there
+  // only because that shape's own regex requires "are" by construction. This
+  // shape (UNKNOWN_SUBJECT_RE) also matches singular "is" sentences ("redis
+  // is a cache"), where singularizing must NEVER run — "redis" naively folds
+  // to "redi" under the same naive -s-strip, a real regression caught live by
+  // the pinned "redis is a cache" tests when this fix first applied
+  // unconditionally. So "all men are mortal" stores under "man" (matching
+  // whatever "john is a man" already typed John as), not the raw plural
+  // "men", while "redis is a cache" stores "redis" untouched. Without this,
+  // findIsaChain's 2-hop proof (john->man, man->mortal) can never join, since
+  // the second fact was keyed on a different string ("men") than the first
+  // fact's object ("man"). classify(subjectRaw, lex) above already folds
+  // plurals for the "is this a real miss" check, so singularizing only the
+  // STORED value here is safe and doesn't change that check's behavior.
+  const subject = /^are$/i.test(verb) ? singularizeSurface(subjectRaw) : subjectRaw;
   // Point 2 (mint-extension): a PRIOR turn's minted term, or a
   // GENERIC_ANCHOR_NOUNS root, grounds Y just as legitimately as a static
   // lexicon noun — both are always treated as class-level (never property),
@@ -2157,14 +2213,14 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   if (lookupNoun(lex, objectRaw) || GENERIC_ANCHOR_NOUNS.has(String(objectRaw).toLowerCase())
     || (await isGroundedByFact(objectRaw, memoryDir))) {
     return teachFact(memoryDir, sessionId, {
-      subject: subjectRaw, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
+      subject, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
     });
   }
   if (lookupAdjective(lex, objectRaw)) {
     // property assertions are about ONE specific entity — never a quantifier,
     // even when phrased with "every" (point 3).
     return teachFact(memoryDir, sessionId, {
-      subject: subjectRaw, predicate: HAS_PROPERTY_PREDICATE, object: objectRaw,
+      subject, predicate: HAS_PROPERTY_PREDICATE, object: objectRaw,
     });
   }
   return null; // Y unknown too — decline honestly, never guess
@@ -2245,9 +2301,9 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon })
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
-  const [, det, subjectRaw, objectRaw] = m;
+  const [, det, subjectRaw, verb, objectRaw] = m;
   if (!/^(?:every|each|all)$/i.test((det || "").trim())) return null; // class-level mint needs a real universal quantifier
-  const { loadLexicon } = await import("./grammar/lexicon.mjs");
+  const { loadLexicon, lookupNoun } = await import("./grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
   const subjectGrounded = await isGroundedTerm(subjectRaw, lex, memoryDir);
   if (!subjectGrounded) return null; // ungrounded subject isn't this fallback's asymmetry — never a guessed mint
@@ -2255,8 +2311,32 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon })
   if (objectGrounded) return null; // object already known — nothing to mint
   if (await objectReadsAsNonNoun(objectRaw)) return null; // reads like an adjective/verb, not a class noun — defer to unknownAdjectiveFallback
   const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
+  // Singularize the SUBJECT before storage, ONLY on a genuinely PLURAL
+  // phrasing (verb "are") — same bug class and same "is"-vs-"are" safety gate
+  // as unknownSubjectFallback, above (see UNKNOWN_SUBJECT_RE's own docblock).
+  // This is the fallback the canonical "all men are mortal" sentence
+  // ACTUALLY goes through: "men" is grounded here via classify's own
+  // IRREGULAR plural-fold (lexicon-core.json declares "man"/plural "men"), so
+  // unknownSubjectFallback itself already declines for it (its own
+  // classify(subjectRaw) check reads "men" as the known noun "man") and hands
+  // off to this mirror fallback instead. A naive suffix-strip
+  // (singularizeSurface — SOME_A_FEW_RE's own tool, reused as the fallback for
+  // a genuinely novel REGULAR plural not in the lexicon, e.g. "zorps") can't
+  // undo an IRREGULAR plural like "men" -> "man" — only the lexicon's own
+  // noun table (lookupNoun, already resolved by isGroundedTerm/classify to
+  // decide this subject counts as grounded in the first place) carries that
+  // mapping, so storage must consult the SAME source of truth: prefer the
+  // lexicon lemma, falling back to singularizeSurface for a subject grounded
+  // only via a PRIOR taught fact (isGroundedByFact) or a regular-plural
+  // lexicon fold. Gated on verb "are" for the identical reason
+  // unknownSubjectFallback gates it: an already-singular grounded subject
+  // that happens to end in "s" (e.g. a fact-grounded "gas") must never be
+  // naively stripped on an "is" sentence ("every gas is a chemical").
+  const subject = /^are$/i.test(verb)
+    ? (lookupNoun(lex, subjectRaw)?.lemma || singularizeSurface(subjectRaw))
+    : subjectRaw;
   return teachFact(memoryDir, sessionId, {
-    subject: subjectRaw, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
+    subject, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
   });
 }
 
@@ -2323,7 +2403,7 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
-  const [, , subjectRaw, objectRaw] = m;
+  const [, , subjectRaw, , objectRaw] = m;
   const { loadLexicon, lookupNoun, classify } = await import("./grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
   // Y already a known NOUN or a fact-grounded CLASS term — a genuine class-
@@ -2647,6 +2727,24 @@ function teachSuggestion(payload) {
  *  way it already stood ahead of teachSuggestion/unknownSubjectFallback. */
 const TEACH_PRONOUN_RE = /^(?:every\s+|each\s+|all\s+|some\s+|a few\s+|a\s+|an\s+)?(you|i|it|they|he|she|we)\s+\S+/i;
 
+/** RETRACTION / NEGATION of an already-taught subClassOf fact (PLAN_SYLLOGIST.md
+ *  §3 finding 1 fix): "X is not a Y" (tolerating the same "kind/type of" infix
+ *  every other teach shape in this lane already tolerates — the "is/are"
+ *  variant, plus the "isn't"/"aren't" contractions). Deliberately narrow — the
+ *  SAFEST, most unambiguous negation phrasing only, matching a scoped 2-token
+ *  subject (mirrors UNKNOWN_SUBJECT_RE's own subject width), never a general
+ *  negation grammar. See the RETRACTION block's own comment in teachLane
+ *  (below) for why a regex match here is only a TRIGGER, never itself proof a
+ *  fact existed to retract — retractSubClassOf (src/syllogise.mjs) is the
+ *  actual authority. */
+const RETRACT_NOT_A_RE = /^(?:a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:(?:is|are)\s+not|isn't|aren't)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?([\w-]+)$/i;
+/** "forget (that) X is a Y" — the second closed retraction phrasing (PLAN_SYLLOGIST.md
+ *  §3 finding 1). Never wrapped by TEACH_RE ("forget" isn't one of its
+ *  recognized lead verbs — remember/note/keep in mind/…), so this is matched
+ *  against the RAW (unwrapped) sentence, unlike RETRACT_NOT_A_RE above which
+ *  is tried against the remember-wrapped surface too. */
+const RETRACT_FORGET_RE = /^forget\s+(?:that\s+)?(?:a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:is|are)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?([\w-]+)$/i;
+
 async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // Tier 6 playtest: this lane read the raw, un-normalized query, so a closed
   // discourse-marker preamble ahead of a teach sentence ("howdy pardner,
@@ -2733,6 +2831,61 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
     };
   }
 
+  // RETRACTION — "X is not a Y" / "forget that X is a Y" (PLAN_SYLLOGIST.md §3
+  // finding 1 fix, 2026-07-12): the data-layer retraction primitive
+  // (retractSubClassOf, src/syllogise.mjs, PLAN_SYLLOGIST.md §3, commit
+  // f7b3644) shipped with no chat-level phrasing ever calling it — confirmed
+  // live, 5 attempts across 2 playtest personas, 0 successes
+  // (BENCHMARK_CONVERSATION_1.8.14.md). Tried here, right after the pronoun
+  // guard, so a pronoun subject ("it is not an animal") still falls to that
+  // guard's own decline first (TEACH_PRONOUN_RE matches ANY verb after the
+  // pronoun, including "is not"), never reaching this block.
+  //
+  // TRIGGER, never itself the authority: RETRACT_NOT_A_RE/RETRACT_FORGET_RE
+  // only recognize the SHAPE of a negation/retraction sentence — they say
+  // nothing about whether subject⊑object was ever actually taught.
+  // retractSubClassOf is asked for real and is the only thing that decides:
+  //   - found:true  → a real stored (or entailed) fact existed and was
+  //     retracted (with its dependency-directed cascade) — confirmed here.
+  //   - found:false → subject⊑object was never a stored fact. This is left
+  //     to FALL THROUGH to the rest of teachLane's ordinary cascade below,
+  //     deliberately NOT answered with a bespoke "nothing to forget" message
+  //     — RETRACT_NOT_A_RE's shape also incidentally matches a NEGATED
+  //     PROPERTY claim ("the logger is not deprecated" — never subClassOf-
+  //     shaped at all, a pinned "genuine ceiling" case elsewhere in this
+  //     codebase, test/chatflow-tier5.test.mjs, that must keep its own
+  //     "I couldn't store that —" decline verbatim), so a bare "nothing
+  //     found" here must never claim a specific, possibly-wrong reason —
+  //     falling through preserves whatever honest response that OTHER shape
+  //     already gets, byte-identical, while still fully closing the real gap
+  //     (an already-taught fact's retraction, which now always succeeds).
+  const retractSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
+  const retractSrcMidQuestion = memoryDir && !QUESTION_LEAD_RE.test(retractSrc)
+    ? await hasMidSentenceInterrogative(retractSrc) : false;
+  const retractNotMatch = memoryDir && !QUESTION_LEAD_RE.test(retractSrc) && !retractSrcMidQuestion
+    ? retractSrc.match(RETRACT_NOT_A_RE) : null;
+  const forgetSrc = raw.replace(/[.!?]+\s*$/, "");
+  const retractForgetMatch = !retractNotMatch && memoryDir && !QUESTION_LEAD_RE.test(forgetSrc)
+    ? forgetSrc.match(RETRACT_FORGET_RE) : null;
+  const retractMatch = retractNotMatch || retractForgetMatch;
+  if (retractMatch) {
+    const retractSubject = retractMatch[1].trim();
+    const retractObject = retractMatch[2].trim();
+    const { retractSubClassOf } = await import("./syllogise.mjs");
+    const result = await retractSubClassOf(memoryDir, retractSubject, retractObject);
+    if (result.found) {
+      const extra = result.count - 1; // beyond the target fact itself
+      return {
+        text: `noted — forgotten: "${retractSubject} is a kind of ${retractObject}" is no longer stored`
+          + (extra > 0 ? ` (${extra} entailed fact${extra === 1 ? "" : "s"} that depended on it went too)` : "")
+          + (result.truncated ? " — this cascade may not be complete (a lot depended on it); ask again if something still looks stale" : "")
+          + ".",
+        via: "retract", miss: false,
+      };
+    }
+    // found:false — fall through to the rest of the cascade (see docblock above).
+  }
+
   // OWNERSHIP — "<Name> owns/maintains <X>", bare or remember-wrapped. The bare
   // form is double-gated: no interrogative lead, PLUS either side spelling a
   // Capitalized token — so the "who owns <X>" READ question and ordinary
@@ -4266,6 +4419,37 @@ const RECURSIVE_LIST_ASK_RE = /^list\s+(?:the\s+|all\s+)?([a-z][\w-]*)\s+of\s+([
 const ISA_ASK_RE = /^(?:is|are)\s+(?:an?\s+)?(.+?)\s+(?:a\s+kind\s+of|a\s+type\s+of|an?)\s+(.+?)[?.!\s]*$/i;
 const ISA_PREDICATES = new Set(["rdfs:subClassOf", "rdf:type"]);
 
+/** "why is TaskController a handler" / "explain how you know TaskController is
+ *  a handler" — BENCHMARK_CONVERSATION_1.8.14.md item 9 (skeptical-power-user
+ *  persona): the syllogise-verified proof render (the isaAsk block below,
+ *  which cites the graph inherits-bridge / taught-fact chase / entailed
+ *  closure) only ever fired on the bare "is X a Y" yes/no form — a "why"/
+ *  "explain how you know" wrapper around the EXACT SAME question hit the bare
+ *  wall instead, even though the underlying answer is real and sourced.
+ *  Deliberately NOT a new answer path — a pure text rewrite back onto
+ *  ISA_ASK_RE's own "is X a Y" shape, mirroring CONFIRM_TAG_RE's own
+ *  "rewrite the wrapper away and re-try ISA_ASK_RE" approach just below (and
+ *  reused at both this file's ISA_ASK_RE match sites, the memory-only isa
+ *  check and the graph-grounded proof-chase). "why is X a Y" already leads
+ *  with "is"/"are" (ISA_ASK_RE's own anchor) — only the "why " lead needs
+ *  stripping; "explain how you know X is Y" leads with the SUBJECT in plain
+ *  declarative order, so it's reordered into "is X a Y" the same way
+ *  CONFIRM_TAG_RE reorders its own "X is Y, right?" tag. Returns ISA_ASK_RE's
+ *  own match array (or null) — a caller never needs to know which of the two
+ *  shapes fired, same discipline as `isaAsk` already applies to CONFIRM_TAG_RE. */
+const WHY_ISA_LEAD_RE = /^why\s+(?=(?:is|are)\b)/i;
+const EXPLAIN_HOW_YOU_KNOW_RE = /^explain\s+how\s+you\s+know\s+(?:that\s+)?(.+?)\s+(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
+function matchWhyIsa(q) {
+  const stripped = String(q || "").replace(WHY_ISA_LEAD_RE, "");
+  if (stripped !== q) {
+    const m = stripped.match(ISA_ASK_RE);
+    if (m) return m;
+  }
+  const ehyk = String(q || "").match(EXPLAIN_HOW_YOU_KNOW_RE);
+  if (ehyk) return `is ${ehyk[1].trim()} a ${ehyk[2].trim()}`.match(ISA_ASK_RE);
+  return null;
+}
+
 // Live-caught 2026-07-11 (follow-up to the "what is a kind of X" ambiguousParse
 // fix, commit 5c858bf): RELATION_FACT_YESNO_RE/RELATION_WHO_ASK_RE both capture a
 // middle "role" word and treat it as an arbitrary user-taught relation/rule NAME
@@ -4432,7 +4616,8 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
   if (!miss) return null;
 
   // (b) "is a module a component" — yes iff a remembered isa-family fact says so.
-  const isa = q.match(ISA_ASK_RE);
+  // 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);
   if (isa) {
     const subj = factTermVariants(normFactTerm, isa[1]);
     const obj = factTermVariants(normFactTerm, isa[2]);
@@ -5429,7 +5614,11 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
   // plain "is X a Y" form and re-tried when the raw query itself doesn't match —
   // see CONFIRM_TAG_RE's own docblock.
   const confirmTag = q.match(CONFIRM_TAG_RE);
-  const isaAsk = q.match(ISA_ASK_RE) || (confirmTag && `is ${confirmTag[1].trim()} a ${confirmTag[2].trim()}`.match(ISA_ASK_RE));
+  // "why is X a Y" / "explain how you know X is Y" (BENCHMARK_CONVERSATION_1.8.14.md
+  // item 9) reach the SAME sourced/verified proof chase below via matchWhyIsa's
+  // rewrite — see its own docblock.
+  const isaAsk = q.match(ISA_ASK_RE) || matchWhyIsa(q)
+    || (confirmTag && `is ${confirmTag[1].trim()} a ${confirmTag[2].trim()}`.match(ISA_ASK_RE));
   if (isaAsk) {
     // Playtest sprint round 1 (2026-07-10): "is TaskController a validator then"
     // — the same trailing bare discourse tag item 8 fixed for metaTermOf's bare
@@ -5916,6 +6105,33 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
           replace: true,
         };
       }
+      // No property hit — but a bare "is X Y" (no article) is exactly the
+      // same claim as "is X a Y" would have been had the user included the
+      // article (ISA_ASK_RE's own territory, above): SKILL_BENCHMARK_CONVERSATION.md's
+      // canonical syllogism ("john is a man" / "all men are mortal" / "is
+      // john mortal") is asked this bare way, and "mortal" was taught as a
+      // CLASS (rdfs:subClassOf), not a property — so it can only ever be
+      // found by the SAME 2-hop TAUGHT-only findIsaChain proof-chase isaAsk
+      // uses above, never by propertyMatch. Tried here as an ADDITIONAL
+      // attempt, never a replacement: on no chain either, this falls through
+      // to the ordinary property-miss handling just below, unchanged.
+      {
+        const { findIsaChain: chaseAdj, SUBCLASS_PREDICATE: SC_PREDICATE_ADJ, TYPE_PREDICATE: TYPE_PREDICATE_ADJ } = await import("./syllogise.mjs");
+        const isTaughtAdj = (f) => !f.sourceTypes?.includes("corpus") && !f.sourceTypes?.includes("web");
+        const chainSubClassRowsAdj = rows.filter((f) => f.predicate === SC_PREDICATE_ADJ && isTaughtAdj(f));
+        const chainTypeRowsAdj = rows.filter((f) => f.predicate === TYPE_PREDICATE_ADJ && isTaughtAdj(f));
+        const chainSubClassEdgesAdj = chainSubClassRowsAdj.map((f) => [f.subject, f.object]);
+        const chainTypeEdgesAdj = chainTypeRowsAdj.map((f) => [f.subject, f.object]);
+        const factForStepAdj = (step) => (step.predicate === SC_PREDICATE_ADJ ? chainSubClassRowsAdj : chainTypeRowsAdj)
+          .find((f) => f.subject === step.subject && f.object === step.object);
+        const adjObjVariants = factTermVariants(normFactTerm, adjective);
+        for (const subj of subjVariants) {
+          const chain = chaseAdj(subj, adjObjVariants, chainTypeEdgesAdj, chainSubClassEdgesAdj, { maxHops: 2 });
+          if (!chain) continue;
+          const premises = chain.map(factForStepAdj);
+          if (premises.every(Boolean)) return { text: `yes — ${renderIsaChain(premises)}`, replace: true };
+        }
+      }
       // no hit on THIS property — never a guessed "no" (see
       // IS_ADJECTIVE_YESNO_RE's own docblock for why this stays silent on a
       // truth claim, unlike its ownership/general-verb siblings above). But a
@@ -6776,20 +6992,33 @@ async function describeWrapperAnswer(query, { config, source, focus, graph, tel
 
 /** COMPARE (HANDOVER.md 2026-07-12 "no comparison capability" item) — a scoped
  *  v1: "how is X different from Y", "how does X differ from Y", "compare X and
- *  Y"/"compare X with/to Y", "what's the difference between X and Y". Five
- *  closed patterns, same discipline as DESCRIBE_WRAPPER_RE/DETAILED_HOW_WORKS_RE
+ *  Y"/"compare X with/to Y", "what's the difference between X and Y". Closed
+ *  patterns, same discipline as DESCRIBE_WRAPPER_RE/DETAILED_HOW_WORKS_RE
  *  above — curated anchors, never a general "any two nouns" catch-all. Named
  *  capture groups (a/b) so compareAnswer doesn't need to know which pattern
  *  fired. Tried as a LAST-RESORT rescue (same call-site discipline as (4d)/(4e)
  *  below) since neither ask.mjs's compositional grammar nor any existing lane
  *  recognizes a two-entity comparison at all — there is nothing for this to
- *  shadow. */
+ *  shadow.
+ *
+ *  BENCHMARK_CONVERSATION_1.8.14.md item 8 (rushed-dev persona): "how is Task
+ *  diff from User" / "whats the diff between TaskController and
+ *  UserController" both hit the bare wall — "diff" is a common casual synonym
+ *  for "different"/"difference" this table never accepted. Folded in as an
+ *  additional alternation on the two patterns it naturally pairs with (never
+ *  a new standalone pattern — "diff" means exactly what "different"/
+ *  "difference" already mean here, so it rides the SAME two anchors). The
+ *  "what's the diff between" anchor also picks up the bare no-apostrophe
+ *  "whats" contraction spelling (`what(?:'s|s|\s+is)`) while here — the same
+ *  tolerance MODULE_ORIENT_RE/MODULE_PURPOSE_RE's own docblock already
+ *  documents elsewhere in this file — since the persona's own verbatim input
+ *  used exactly that spelling. */
 const COMPARE_PATTERNS = [
-  /^how\s+(?:is|are)\s+(?<a>.+?)\s+different\s+from\s+(?<b>.+?)$/i,
+  /^how\s+(?:is|are)\s+(?<a>.+?)\s+(?:different|diff)\s+from\s+(?<b>.+?)$/i,
   /^how\s+do(?:es)?\s+(?<a>.+?)\s+differ\s+from\s+(?<b>.+?)$/i,
   /^how\s+are\s+(?<a>.+?)\s+and\s+(?<b>.+?)\s+different$/i,
   /^compare\s+(?<a>.+?)\s+(?:and|with|to)\s+(?<b>.+?)$/i,
-  /^(?:what(?:'s|\s+is)\s+the\s+difference\s+between|difference\s+between)\s+(?<a>.+?)\s+and\s+(?<b>.+?)$/i,
+  /^(?:what(?:'s|s|\s+is)\s+the\s+(?:difference|diff)\s+between|(?:difference|diff)\s+between)\s+(?<a>.+?)\s+and\s+(?<b>.+?)$/i,
 ];
 
 /** Strip a leading article — resolveSymbol (codegraph.mjs) has no article
@@ -7313,7 +7542,41 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     }
   }
   const answeredIds = (envelope?.matches || []).map((m) => m?.id).filter(Boolean);
-  const miss = envelope ? !!envelope.miss : true;
+  const askMiss = envelope ? !!envelope.miss : true;
+  // GRAPH-FACT-VS-TAUGHT-FACT PRECEDENCE (PLAN_SYLLOGIST.md finding 2 fix,
+  // 2026-07-12): a plain declarative "X is a kind of Y" sentence whose SUBJECT
+  // already names a real graph entity could get silently "answered" by the ask
+  // engine's own relaxation cascade instead of ever reaching the teach lane.
+  // Root cause, verified live against examples/mini-webapp: relaxParse's
+  // DROP-UNMATCHED layer (src/ask.mjs "Layer 2") drops an unresolvable trailing
+  // content word ("animal" — not a graph entity) entirely, turning "a Task is a
+  // kind of animal" into the DIFFERENT, valid elliptical question "a Task is a
+  // kind of" (a forward "inherits" ask), which genuinely answers "Record" (Task
+  // really does inherit Record in the code graph) — envelope.miss comes back
+  // false, so the miss-gated TEACH lane (4) below never even ran. That graph
+  // answer must keep working as a QUESTION ("what is Task a kind of" must still
+  // say Record) — the actual bug is only that a DECLARATIVE sentence
+  // (subject-first, no question lead) with a genuine content word dropped by
+  // relaxation never got a chance to be taught at all. Detected narrowly (all
+  // three must hold): the ask engine's answer came via envelope.relaxed
+  // (something was dropped/repaired, not a clean direct hit), the raw query is
+  // NOT phrased as a question (QUESTION_LEAD_RE, no trailing "?"), and it
+  // independently fits the closed "X is a kind of Y" teach shape
+  // (DECLARATIVE_KIND_OF_RE). When all three hold, this turn is treated as a
+  // would-miss so the ordinary miss-gated cascade below (including the
+  // existing TEACH lane (4)) gets a real turn at it — a genuinely stored taught
+  // fact wins over a repaired-away graph reading, COEXISTING with it rather
+  // than replacing it: the graph fact itself is never touched and stays
+  // answerable through its own question phrasing. If nothing below actually
+  // stores it (recordMiss still true once the whole would-miss cascade has
+  // run), the ORIGINAL ask-engine answer is restored unchanged just before the
+  // record is built (see "COLLISION RESTORE" below) — never worse than today.
+  const trimmedQuery = String(query).trim();
+  const relaxedTeachCollision = !!(envelope?.relaxed?.dropped?.length) && !askMiss && memoryDir
+    && !QUESTION_LEAD_RE.test(trimmedQuery) && !/\?\s*$/.test(trimmedQuery)
+    && DECLARATIVE_KIND_OF_RE.test(trimmedQuery);
+  const preCollisionAnswer = relaxedTeachCollision ? answer : null;
+  const miss = askMiss || relaxedTeachCollision;
   // Answer provenance (W1): "composed" is the ask engine's productive band; the
   // orientation swap below is template wording, so those turns carry via:"template".
   let via = "composed";
@@ -7360,6 +7623,11 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // 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);
+  // Paired with preCollisionAnswer above: the goal line that matched the
+  // ORIGINAL ask-engine answer, restored alongside it (COLLISION RESTORE,
+  // below) if the would-miss cascade below never actually stores anything —
+  // so a restored graph answer never carries a stale "teach a new fact" goal.
+  const preCollisionDeduced = relaxedTeachCollision ? deduced : null;
   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
@@ -7518,8 +7786,25 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // factAnswer itself declines for this shape (no metaTerm), so the only
   // change in practice is that factReadBack's (a2c) property lane gets a
   // chance to run before the orientation card claims the turn.
-  const bareWhatisShape = BARE_WHATIS_RE.test(String(query).trim());
-  const isAdjectiveShape = IS_ADJECTIVE_YESNO_RE.test(String(query).trim());
+  // BENCHMARK_CONVERSATION_1.8.14.md item 11: "hey quick q, what is TaskController"
+  // (a leading filler clause) and "whats UserController" (a no-apostrophe
+  // contraction) both used to test the RAW `query` text against BARE_WHATIS_RE/
+  // IS_ADJECTIVE_YESNO_RE's own anchored `^what`/`^is` gate directly — so neither
+  // ever reached this lane at all, even though normalizeQuery (already imported
+  // here, same NO_FOCUS_WHATS_IN_HERE_RE precedent above in this file) already
+  // resolves both: its CONTRACTIONS table expands "whats" -> "what is", and its
+  // stripFillerWords pass (commit 282c010, now covering "quick q" too — see
+  // FILLER_WORDS' own docblock, ask-vocab.mjs) peels the leading "hey quick q,"
+  // clause. Composed from those two EXISTING mechanisms rather than a third:
+  // `gateQuery` is normalizeQuery's output, used for the shape gate AND the
+  // lookups it feeds (metaTermOf/factAnswer/factReadBack/curatedDefinitionAnswer)
+  // so a filler-wrapped/no-apostrophe query resolves to the SAME real answer its
+  // clean form already does — never a new answer path. Idempotent on already-
+  // clean text (normalizeQuery's own contract), so the ordinary case is
+  // byte-unchanged.
+  const gateQuery = normalizeQuery(String(query));
+  const bareWhatisShape = BARE_WHATIS_RE.test(gateQuery);
+  const isAdjectiveShape = IS_ADJECTIVE_YESNO_RE.test(gateQuery);
   // HANDOVER.md 2026-07-12 CamelCase finding: `isBareCamelCaseMetaQuestion` (see
   // its own docblock, above isConversational) OR's in alongside
   // isConversationalCandidate for THIS lane only — a bare "what is TaskController"
@@ -7531,12 +7816,12 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // alone: the `else if (isConversationalCandidate)` orientation-card fallback
   // further down is UNCHANGED, so a CamelCase term with no real hit still falls
   // through to its existing miss handling, never the generic orientation card.
-  const isBareCamelCaseWhatisCandidate = conversationalCandidateBaseGate && isBareCamelCaseMetaQuestion(query);
+  const isBareCamelCaseWhatisCandidate = conversationalCandidateBaseGate && isBareCamelCaseMetaQuestion(gateQuery);
   let bareMetaHit = null;
   if ((isConversationalCandidate || isBareCamelCaseWhatisCandidate) && (bareWhatisShape || isAdjectiveShape)) {
     if (memoryDir) {
-      bareMetaHit = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle))
-        ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle));
+      bareMetaHit = (await factAnswer(memoryDir, gateQuery, envelope, miss, biasByBundle))
+        ?? (await factReadBack(memoryDir, gateQuery, envelope, miss, graph, newFocus?.label, biasByBundle));
       // HANDOVER.md 2026-07-10 item 10 (dropped-article gap): a bare "what is X"
       // with NO taught fact but a KNOWN curated corpus term ("what is cache", no
       // article) used to lose this exact same isConversationalCandidate race —
@@ -7546,7 +7831,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       // lane — an unknown bare term still falls through to the ordinary
       // orientation card, exactly as before.
       if (!bareMetaHit) {
-        const def = await curatedDefinitionAnswer(query, envelope, { memoryDir, lexicon });
+        const def = await curatedDefinitionAnswer(gateQuery, envelope, { memoryDir, lexicon });
         if (def) bareMetaHit = { text: def.text, replace: true };
       }
     }
@@ -7563,7 +7848,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // graph but no memoryDir at all, so gating this on memoryDir too would
     // silently never fire in the one harness this fix specifically targets.
     if (!bareMetaHit && graph) {
-      const term = metaTermOf(query, envelope);
+      const term = metaTermOf(gateQuery, envelope);
       if (term) {
         const { metaFallbackEntityAnswer } = await import("./ask.mjs");
         const fallback = metaFallbackEntityAnswer(graph, term);
@@ -7955,6 +8240,23 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       }
     }
   }
+  // COLLISION RESTORE (pairs with relaxedTeachCollision, above): the whole
+  // would-miss cascade above (TEACH lane included) has now had its turn. If
+  // nothing in it actually stored/answered anything (recordMiss is still
+  // true), fall back to the ORIGINAL ask-engine answer computed before this
+  // turn was forced into the would-miss cascade — a real graph answer beats
+  // any generic miss/wall text, and this is never worse than the turn would
+  // have rendered before this fix existed. If the TEACH lane (or any other
+  // lane) DID answer for real, recordMiss is already false here and this is a
+  // no-op — the taught fact's own confirmation stands, coexisting with the
+  // (untouched) graph fact.
+  if (relaxedTeachCollision && recordMiss) {
+    answer = preCollisionAnswer;
+    via = "composed";
+    recordMiss = false;
+    deduced = preCollisionDeduced;
+    note(trace, "lane: COLLISION RESTORE — the teach-shaped declarative wasn't storable after all; the original ask-engine (graph) answer stands, untouched");
+  }
   // W5 (flag-gated, default OFF): an unknown-term miss may consult the LOCAL
   // committed corpus slice — a hit APPENDS a grounded, licence-cited aside under
   // the honest miss (the miss itself stands; the aside is context, not an answer).