@polycode-projects/the-mechanical-code-talker 0.4.0 → 0.5.0

package/README.md

@@ -37,7 +37,7 @@ fit the grammar still gets the tolerant strategies; nothing is rejected for
 being loose, fuzzy, or misspelled.
 
 **Negation and passive.** "Which modules do *not* import X?" computes a bounded
-**set complement** over the graph — and an honestly empty result stays a miss
+**set complement** over the graph, and an honestly empty result stays a miss
 rather than a fabricated list (a non-enumerable type, like arbitrary *changes*,
 is refused outright). Reversible-passive questions traverse the right direction:
 "what is imported by Y" and "what does Y import" are understood as opposite
@@ -73,8 +73,8 @@ web scrape, a rule-derived entailment — and a fact links back to *all* of them
 (`mgx:derivedFrom` / `mgx:statedBy` / `mgx:canonicalisedFrom`), timestamped with
 `mgx:createdAt`. From those links tmct computes a **deterministic, explainable
 trust score** — a source-type prior combined with corroboration (how many
-independent sources agree) and recency — never hand-set, always traceable to its
-inputs. Retrieval then ranks by **relevance × trust**, so a corroborated,
+independent sources agree) and recency. It is never hand-set, always traceable
+to its inputs. Retrieval then ranks by **relevance × trust**, so a corroborated,
 operator-stated fact outranks a lone web scrape on the same question. When two
 trusted sources *disagree*, the `/memory` inspector shows **both sides with their
 provenance** rather than silently picking a winner.
@@ -95,7 +95,7 @@ on the chat's hot path.
   a code graph is out of scope. tmct's job is the *conversation*.
 - **It is not a reasoning model.** Where it "reasons", it does so by
   *calculation* surfaced as prose ("there are a lot of tests for a codebase of
-  that size") — deterministic, explainable, cheap. Even its forward-chaining
+  that size"). It is deterministic, explainable, and cheap. Even its forward-chaining
   entailment (`tmct syllogise`) is mechanical OWL rule materialization applied
   offline, rule-by-rule and retractable — not an LLM. There is **no LLM anywhere
   in the product**. (An LLM-as-judge exists only in the offline eval harness

package/ROADMAP.md

@@ -2,7 +2,7 @@
 
 tmct v0.1.0 was a **whole-package lift** of the seonix chat surface (published
 as `@polycode-projects/mct`): identical shape, green tests, new branding. That
-was deliberate — it gave every ambition below a working, tested starting point
+was deliberate. It gave every ambition below a working, tested starting point
 instead of a green field. v0.2.0 is the **reshape**: the lift's LLM fallback,
 extraction stack, and MCP server are gone, and the package, naming, and license
 now match the product this document describes.
@@ -228,7 +228,7 @@ then use Progol to theorem-prove against parsed prose".)*
 
 ## Phase 4 — The wiring wave (operator-directed 2026-07-04)
 
-Five subsystems are built, tested, and consumed by NOTHING in the answer path — they measured
+Five subsystems are built, tested, and consumed by NOTHING in the answer path. They measured
 zero on case-set v1 because no case could see them. This phase wires each into answering, with
 **unit tests at the seam AND graded-benchmark cells that measure it** (the graded pool creates
 the cases that make each lever visible). Wired as one operator-directed wave; cycle-level
@@ -406,7 +406,7 @@ answer EXISTS as a stable phrasing in technical prose is not a ceiling — it is
 > Detailed plan: **`PLAN_RESPONSE_FINISHING.md`**.
 
 *(Refined 2026-07-05; decisions settled with the operator. Fact invariance is achieved by
-CONSTRUCTION, not by hope — finishing operates over a SEGMENTED answer, never a raw string.
+CONSTRUCTION, not by hope. Finishing operates over a SEGMENTED answer, never a raw string.
 Tone-of-voice synonym substitution is DROPPED: once every term with technical significance is
 protected — entities, paths, vocabulary, receipts, provenance — the substitutable surface is
 mostly connectives: high accuracy risk, thin reward. "Keen on the trickery to make a helpful
@@ -466,7 +466,7 @@ a passive payload loader into the product's primary integration surface.)*
 - **tmct defines the adapter shape** — not the producer. Rationale: tmct is the brittle side
   (query interpretation), so it must own and optimize around a STABLE interface; because the
   vocabulary is OWL-grounded, the human/code world is already quantized into types both sides
-  understand — the interface is built from those shared types, not ad-hoc JSON.
+  understand, so the interface is built from those shared types, not ad-hoc JSON.
 - **A rich instruction set, translated from what seonix already exposes**: survey seonix's
   native tool surface (describe / members / subclasses / impact / callers / callees / tests-for /
   untested / history / exports / architecture / search / context / snippet / locate / digest —
@@ -521,7 +521,7 @@ exactly when pre-deriving the useful closure pays off). Never on the chat's hot
 
 **The selection criterion, sharpened by the operator (2026-07-05):** the guiding question is
 *"what do the assertions of the sources I TRUST allow me to infer about this topic that is of
-RELEVANCE"* — so **novelty × trust is the primary driver**, not an afterthought: the pass walks
+RELEVANCE"* — so **novelty × trust is the primary driver**: the pass walks
 outward from high-trust premises (the provenance primitive) toward novel, relevant conclusions,
 timestamping each so recency and novelty stay computable. The mechanics are the easy half
 (bounded forward chaining materializes entailments; backward chaining from frequent query shapes
@@ -530,7 +530,7 @@ realization — unsolved in the general case and not pretended otherwise;** trus
 are the tractable approximation, not a solution. The plan's job is
 to make it TRACTABLE in tmct's narrow, closed world, not to solve it: usefulness is approximated
 from what the system actually gets asked (query-shape frequency), what connects to recent focus,
-what a cheap forward step yields that isn't already stored, and — the honest guardrail — a hard
+what a cheap forward step yields that isn't already stored, and a hard
 budget (inference is bounded, its output trust-scored via the provenance primitive, and anything
 speculative is retractable and never outranks a stated fact). Everything else is deferred to the
 plan's open questions, where the relevance problem is named as the open research risk it is.

package/data/templates/grammar-rules.toml

@@ -16,14 +16,22 @@
 # chosen to commute so finish() is idempotent: finish(finish(x)) === finish(x).
 #
 # SEQUENCING (PLAN_RESPONSE_FINISHING.md, "one grammar rule per tuning cycle"):
-# only ARTICLE-SELECTION is live this cycle — it fixes a genuine defect with a
-# narrow, safe blast radius. AGREEMENT, CAPITALISATION, LIST and TERMINAL are
-# fully implemented and golden-tested IN ISOLATION, but PARKED (enabled=false):
-# each rewrites established product bytes (tmct's lowercase openers and repeated
-# "and" joins are an intentional VOICE, not a grammar defect), so activating them
-# is a per-rule tuning-cycle decision with its own bench + showcase reconcile,
-# not a blanket flip. `enabled=false` keeps them inert in finish(); the goldens
-# force-enable each rule to prove its behaviour independent of the live flag.
+# LIVE as of cycle 005: ARTICLE-SELECTION (cycle 4), plus the two SAFE defect
+# fixes TERMINAL-PUNCTUATION and SUBJECT-VERB-AGREEMENT — each byte-stable when
+# neutral, no product-voice change. CAPITALISATION and LIST are fully implemented
+# and golden-tested IN ISOLATION but remain PARKED (enabled=false). The cycle-006
+# judged A/B was assessed and DROPPED: `capitalise` rewrites the sentence-initial
+# char, which regresses ~10 frozen v1 cases.jsonl whose case-sensitive answerMatch
+# pins lowercase openers ("can't count", "no symbol matching", "assuming you meant",
+# …) — the same sacred-case collision that reverted the voice-nit; and `list` has
+# zero 3-item "X and Y and Z" targets in the judged set (a no-op). Deferred to a
+# post-arc case-set refresh where the openers can be re-pinned deliberately. They
+# rewrite established product bytes (tmct's
+# lowercase openers and repeated "and" joins are an intentional VOICE, not a
+# grammar defect), so activating them is a per-rule tuning-cycle decision with
+# its own bench + showcase reconcile, not a blanket flip. `enabled=false` keeps
+# them inert in finish(); the goldens force-enable each rule to prove its
+# behaviour independent of the live flag.
 
 # 1. Article selection — a/an by the following word's phonetic onset. The live
 #    defect this fixes: the assert echo "every module is a artifact" -> "an
@@ -48,7 +56,7 @@ vowel_sound_consonants = ["hour", "honest", "honour", "honor", "heir", "herb"]
 [[rule]]
 id = "subject-verb-agreement"
 kind = "agreement"
-enabled = false   # PARKED — implemented + golden-tested, not live this cycle
+enabled = true    # LIVE (cycle 005) — structure-driven existential agreement, byte-stable when neutral
 registers = []
 description = "existential copula agrees with the following count/plurality"
 singular = ["is", "was", "has"]
@@ -83,7 +91,7 @@ separator = ", "
 [[rule]]
 id = "terminal-punctuation"
 kind = "terminal"
-enabled = false   # PARKED — implemented + golden-tested, not live this cycle
+enabled = true    # LIVE (cycle 005) — pure defect fix, narrowest blast radius (trailing doubled stop)
 registers = []
 description = "collapse a run of trailing sentence stops to a single stop"
 stops = [".", "!", "?"]

package/package.json

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

@@ -245,6 +245,7 @@ function parseComposite(text, nlp) {
   const w = splitWords(text);
   const lc = w.map((x) => x.toLowerCase());
   return parseNegation(text, nlp, 0)
+    || parseForwardNegation(w, lc, nlp)
     || parseAnaphora(w, lc, nlp)
     || parseAggregate(w, lc, nlp)
     || parseSuperlative(w, lc, nlp)
@@ -318,6 +319,54 @@ function parseNegation(text, nlp, depth = 0) {
   return complementAst(entityType, { op: "difference", kind: "set", ast: positive });
 }
 
+// B1 FORWARD NEGATION (Cycle 5, pron+neg) — the SUBJECT-side complement's mirror: "what
+// does[n't] <subj> <verb>" ("what doesn't it import", "what does app/lib/e.mjs not import")
+// is every individual of the verb's OBJECT grain that <subj> does NOT reach via that verb.
+// Distinct from parseNegation (which negates a queried KIND — "which modules do not import
+// X"): here the negation sits on a FORWARD clause whose subject is a named term or a focus
+// pronoun, so the universe is inferred from the verb's own edges (imports → Module) rather
+// than a stated kind noun. The subject is resolved LATE (at eval, through the same
+// contextId a plain "it" uses), so pronoun-binding composes with the complement for free.
+// Refused honestly (empty) when the verb's object grain is ambiguous or the subject can't
+// resolve — never a guess. Runs AFTER parseNegation, so the stated-kind form is unaffected.
+const FWD_NEG_FRAME = new Set(["what", "which", "thing", "things", "one", "ones", "stuff"]);
+function parseForwardNegation(w, lc, nlp) {
+  let i = 0;
+  while (i < lc.length && FWD_NEG_FRAME.has(lc[i])) i += 1;
+  if (!["do", "does", "did"].includes(lc[i])) return null;   // need the auxiliary lead
+  i += 1;
+  const rest = w.slice(i);
+  const restLc = lc.slice(i);
+  const notIdx = restLc.indexOf("not");
+  if (notIdx < 0) return null;                                // no negation → not this shape
+  const vh = findPhrase(restLc, VERB_TO_KIND);
+  if (!vh) return null;                                       // no relation verb → not this shape
+  // the subject term is whatever survives after removing "not", the verb phrase, "from",
+  // and question scaffolding — a bare pronoun "it" (not a stopword) survives and binds to
+  // the focus at eval time; a named module/symbol survives and resolves directly.
+  const subjTokens = rest.filter((_, j) => j !== notIdx && (j < vh.start || j >= vh.end)
+    && restLc[j] !== "from" && !STOPWORDS.has(restLc[j]));
+  const subjectTerm = subjTokens.join(" ").trim();
+  if (!subjectTerm) return null;
+  return { node: "forwardComplement", kind: vh.kind, subjectTerm };
+}
+
+/** The single OBJECT class a forward relation kind points at across the loaded graph
+ *  (imports → Module), or null when its objects span more than one class (an ambiguous
+ *  grain the complement's universe can't be pinned to). Ext: endpoints have no individual,
+ *  so they don't muddy the class vote. Used by the forwardComplement evaluator to bound
+ *  the universe it differences the positive forward set out of. */
+function kindObjectClass(graph, kind) {
+  const classes = new Set();
+  for (const k of kindsFor(kind)) {
+    for (const e of edgesOfKind(graph, k)) {
+      const o = graph.byId.get(e.object);
+      if (o && o.class) classes.add(o.class);
+    }
+  }
+  return classes.size === 1 ? [...classes][0] : null;
+}
+
 /** A set-producing sub-expression (used for nested inner clauses, boolean branches,
  *  and count restrictors): nested first, then the relational/qualifier/boolean
  *  parser, then a bare simple clause. Carries `depth` for the nesting cap. */
@@ -373,12 +422,21 @@ function parseNested(w, lc, nlp, depth) {
  *  uncompilable), or null. */
 function parseAnaphora(w, lc, nlp) {
   let p = -1;
+  let viaOf = false;
   for (let i = 1; i < lc.length; i += 1) {
-    if (ANAPHORA_TRIGGERS.includes(lc[i]) && lc[i - 1] === "of") { p = i; break; }
+    if (!ANAPHORA_TRIGGERS.includes(lc[i])) continue;
+    if (lc[i - 1] === "of") { p = i; viaOf = true; break; } // "how many of those", "which of them"
+    // BARE anaphoric pronoun as the FINAL word, directly after a count/list trigger
+    // ("count them", "count those", "list them") — the discourse-reference count/list over
+    // the previous answer with no "of" (Cycle 5, disc+count). Pinned to the terminal
+    // position so a mid-sentence "these"/"those" used as a determiner ("list these
+    // functions") is left for the ordinary list/clause path, not seized as an anaphor.
+    const headSoFar = lc.slice(0, i).join(" ");
+    if (i === lc.length - 1 && (AGGREGATE_TRIGGERS.includes(headSoFar) || LIST_TRIGGERS.includes(headSoFar))) { p = i; break; }
   }
   if (p < 0) return null;
-  const head = lc.slice(0, p - 1).join(" ");
-  const mode = /^(how many|how much|count)\b/.test(head) ? "count" : "list";
+  const head = (viaOf ? lc.slice(0, p - 1) : lc.slice(0, p)).join(" ");
+  const mode = AGGREGATE_TRIGGERS.includes(head) || /^(how many|how much|count|number|quantity|total)\b/.test(head) ? "count" : "list";
   const filter = parsePredicateFilter(w.slice(p + 1), nlp);
   if (filter === undefined) return { node: "miss", reason: "the follow-up filter didn't parse" };
   return { node: "anaphora", mode, filter };
@@ -772,6 +830,16 @@ function evalSet(graph, ast, opts) {
       const subs = new Set(kindsFor(ast.kind).flatMap((k) => edgesOfKind(graph, k)).map((e) => e.subject));
       return graph.individuals.filter((i) => subs.has(i.id) && (!ast.entityType || i.class === ast.entityType));
     }
+    // forward complement: the verb's object-grain universe MINUS what the (late-resolved,
+    // focus-bindable) subject reaches via that verb — "what doesn't it import".
+    case "forwardComplement": {
+      const r = resolveTermOrContext(graph, ast.subjectTerm, opts && opts.contextId);
+      if (!r.match) return [];                              // unresolved subject / focus-less pronoun → honest empty
+      const universeType = kindObjectClass(graph, ast.kind);
+      if (!universeType) return [];                         // ambiguous object grain → refuse honestly
+      const positive = new Set(forwardOverSet(graph, ast.kind, new Set([r.match.id])).map((x) => x.id));
+      return graph.individuals.filter((i) => i.class === universeType && !positive.has(i.id));
+    }
     case "reverseSet": {
       const ids = new Set(evalSet(graph, ast.inner, opts).map((i) => i.id));
       return reverseOverSet(graph, ast.kind, ast.entityType, ids);
@@ -1401,11 +1469,23 @@ export function traverse(graph, parsed, { contextId = null, prev = null } = {})
     };
   }
 
-  // reverse: "which <entityType> R <objMatch>"
+  // reverse: "which <entityType> R <objMatch>". GRAIN-AWARE (Cycle 5, lever 3): a kind
+  // that carries a symbol-grain sibling reads off the SIBLING when a fine SUBJECT grain
+  // was asked for ("which functions call X" → callsSymbol). Additionally, for `touches`
+  // specifically, when the RESOLVED OBJECT is itself a fine symbol the answer MUST read off
+  // touchesSymbol: touches is Commit→Module (module-coarse) and can NEVER point at a
+  // symbol, so "how many commits touched Widget.render" used to scan the module-grain
+  // edges and return a false 0 — the count belongs at symbol grain. This object-driven
+  // switch is scoped to touches on purpose: calls/callsSymbol already resolve a fine
+  // object through the fine-entityType branch, and a null-entityType "what calls <fn>"
+  // deliberately keeps its module-coarse `calls` receipt (the honest-empty showcase pins
+  // it), so widening the switch to calls would silently change that answer.
   const symbolKind = SYMBOL_GRAIN_SIBLING[kind];
-  if (symbolKind && FINE_ENTITY_TYPES.has(entityType)) {
+  const objIsTouchedSymbol = kind === "touches" && !!(objMatch.class && FINE_ENTITY_TYPES.has(objMatch.class));
+  if (symbolKind && (FINE_ENTITY_TYPES.has(entityType) || objIsTouchedSymbol)) {
     const edges = edgesOfKind(graph, symbolKind).filter((e) => e.object === objMatch.id);
-    const matches = edges.map((e) => graph.byId.get(e.subject)).filter((i) => i && i.class === entityType);
+    const subjects = uniqueById(edges.map((e) => graph.byId.get(e.subject)).filter(Boolean));
+    const matches = (!entityType || entityType === "Change") ? subjects : subjects.filter((i) => i.class === entityType);
     return { matches, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}`, ambiguous, matchedVia };
   }
 
@@ -1662,6 +1742,10 @@ function renderCore(parsed, result) {
         miss: true, ambiguous: false,
       };
     }
+    // NOTE (Cycle 5): a voice-nit rephrasing ("that directly <verb>") was reverted —
+    // the frozen v1 cases.jsonl pins the "whose module directly <verb>s X" wording
+    // (hm-empty-result-calls / tf-wat-calls / ns-wondering), and the case set is
+    // append-only/sacred mid-arc, so the honest-miss phrasing stays as-is.
     const entityWord = nounFor(parsed.entityType || "Module", 2);
     return {
       content: `No ${entityWord} found whose module directly ${verbFor(parsed.kind)} ${parsed.object}. (traversal: ${result.traversal || "no traversal resolved"})`,

package/src/chat.mjs

@@ -138,11 +138,22 @@ function countableKinds(graph) {
   return Object.keys(CLASS_LABELS).filter((c) => present.has(c)).map((c) => CLASS_LABELS[c][1]);
 }
 
+/** A discourse-anaphoric count/list head — "how many [of] those/them/these",
+ *  "count them/those/these". These refer to the previous answer set and are owned
+ *  by the ask engine's anaphora node, never the header-count path. */
+const ANAPHORA_COUNT_RE = /\b(?:how many|how much|count|number of)\s+(?:of\s+)?(?:those|them|these)\b/i;
+
 /** Recognise a count/aggregate question and answer it from the graph header, or
  *  null if it isn't one (→ fall through to tmct_ask). "how many X [are there]",
  *  "count [the] X", "number of X". An unknown kind lists what it CAN count. */
 export function answerCount(graph, query) {
   if (!graph) return null;
+  // ANAPHORIC counts ("how many of those are tested", "count them", "how many of
+  // them") count the PREVIOUS answer's set, not a graph kind — decline so the turn
+  // falls through to the ask engine's anaphora node (which threads `prev`). Without
+  // this the bare "of"/pronoun head is mis-reported as an uncountable kind and the
+  // discourse+count follow-up dies before it can resolve (CHATBENCH_006 lever 1).
+  if (ANAPHORA_COUNT_RE.test(String(query))) return null;
   const m = String(query).match(/\b(?:how many|number of|count(?:\s+the)?)\s+([a-z]+)\b/i);
   if (!m) return null;
   const noun = m[1].toLowerCase();
@@ -155,6 +166,31 @@ export function answerCount(graph, query) {
   return `${n} ${classNoun(cls, n)}.`;
 }
 
+/** ASSERTED-VOCABULARY count (CHATBENCH_006 lever 3): once "every class is a type"
+ *  is remembered, "how many types are there" counts as many types as there are
+ *  classes — the asserted object noun inherits the subject class's cardinality.
+ *  Consulted only when answerCount can't map the noun to a graph class (an unknown
+ *  kind) AND a session's memory is in hand. Returns the count string or null (no
+ *  such fact → the honest "I can't count …" from answerCount stands). */
+async function countFromFacts(graph, memoryDir, query) {
+  if (!graph || !memoryDir) return null;
+  const m = String(query).match(/\b(?:how many|number of|count(?:\s+the)?)\s+([a-z]+)\b/i);
+  if (!m) return null;
+  const asked = m[1].toLowerCase();
+  if (COUNT_NOUNS[asked]) return null; // a real graph kind — answerCount owns it
+  let normFactTerm;
+  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  const objVariants = factTermVariants(normFactTerm, asked);
+  const isa = (await factRows(memoryDir))
+    .filter((f) => ISA_PREDICATES.has(f.predicate) && objVariants.has(f.object));
+  // pick the highest-trust asserted subject that maps to a countable graph class
+  for (const f of isa.sort((a, b) => (b.trust ?? 0) - (a.trust ?? 0))) {
+    const cls = COUNT_NOUNS[String(f.subject).toLowerCase()];
+    if (cls) { const n = countClass(graph, cls); return `${n} ${asked}.`; }
+  }
+  return null;
+}
+
 /** `/stats`: a one-screen overview of the graph — class counts, relationship
  *  (predicate) counts, and module/package totals — read straight off the header. */
 export function renderStats(graph) {
@@ -623,39 +659,121 @@ async function factAnswer(memoryDir, query, envelope, miss) {
   return null;
 }
 
-/** ASSERT-RECALL READ-BACK (PLAN_CYCLE_4 tail): after "every X is a Y" is
- *  asserted, the *superclass* side is otherwise unqueryable — factAnswer's meta
- *  path matches fact SUBJECTS only, so "what is a Y" (Y the asserted OBJECT) dies
- *  as an honest miss ("'component' isn't a term in this graph's own vocabulary")
- *  even though the fact "X is a kind of Y" is remembered. This is the REVERSE-
- *  membership reader: it consults readFactRows (trust-bearing) for isa-family
- *  facts whose OBJECT is the asked term and reports the members, citing each
- *  fact's provenance verbatim, higher-trust first. Miss-only and run AFTER
- *  factAnswer returns null, so it never shadows the subject-side answer or a
- *  schema hit. Returns { text, replace:true } or null (the miss stands). */
-async function factReadBack(memoryDir, query, envelope, miss) {
+/** "what did i tell you about X" — the multi-turn recall phrasing (a sibling of
+ *  factAnswer's "what do you know about X" KNOW_ABOUT form): everything remembered
+ *  that mentions X on either side. */
+const TOLD_ABOUT_RE = /^what\s+(?:did|have)\s+(?:i|we|you)\s+(?:told|tell|said|say)\s+(?:you|me|us)?\s*about\s+(.+?)[?.!\s]*$/i;
+/** "what kind of thing is an X" — the subject-side membership phrasing the grammar
+ *  doesn't parse: reports X's OWN remembered type (falling back to X's members). */
+const KIND_OF_RE = /^what\s+kind\s+of\s+(?:thing|class|type|category|entity)?\s*(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
+/** WHOLE-STORE recall (CHATBENCH_006 lever 3): "what did i tell you [last time]",
+ *  "what facts do you know", "what do you remember" — list EVERY remembered fact
+ *  (no subject/object term to filter on), cited, higher-trust first. The multi-turn
+ *  / cross-session assert-recall surfaces that carry no term the grammar can bind. */
+const WHOLE_RECALL_RE = /^(?:what\s+(?:did|have)\s+(?:i|we)\s+(?:told?|tell|said?|say)\s+(?:you|me|us)?(?:\s+(?:last\s+time|before|earlier|previously|already))?|what\s+facts?\s+do\s+you\s+(?:know|have|remember)|what\s+do\s+you\s+(?:know|remember)|what\s+have\s+you\s+(?:learned|learnt|remembered))[?.!\s]*$/i;
+
+/** The singular class-noun of the graph entity a term names ("app/lib/a.mjs" →
+ *  "module", "Widget" → "class"), via the ask engine's own resolver + the loaded
+ *  graph's class map — or null on a miss/ambiguity/no-graph. Lets forward
+ *  membership answer over a graph INSTANCE, not just a bare class word. */
+async function entityClassNoun(graph, term) {
+  const ent = await resolveEntity(graph, term);
+  if (!ent) return null;
+  const cls = (graph?.byId?.get?.(ent.id) || (graph?.individuals || []).find((i) => i?.id === ent.id))?.class;
+  return cls && CLASS_LABELS[cls] ? CLASS_LABELS[cls][0] : null;
+}
+
+/** ASSERT-RECALL MULTI-TURN READ-BACK (PLAN_CYCLE_4 tail → cycle-005 lever 2):
+ *  once "every X is a Y" is asserted in an earlier turn, the graded assert-recall
+ *  cells (B2/C1 assert) query it back across turns in shapes the graph grammar
+ *  can't parse — so each dies as an honest miss even though "X is a kind of Y" is
+ *  remembered. This reader answers those declare-then-recall shapes from the
+ *  reified Facts (readFactRows — trust-bearing), citing each fact's provenance
+ *  verbatim, higher-trust first:
+ *    (a) FORWARD membership "is an X a Y" — X a class WORD ("is a module a
+ *        component") OR a graph INSTANCE ("is app/lib/a.mjs a component", resolved
+ *        to its class-noun) — yes iff a remembered isa-family fact says so;
+ *    (b) RECALL "what did i tell you about X" — every remembered fact mentioning X;
+ *    (c) REVERSE membership — "what is a Y" reports Y's members (object-side), and
+ *        "what kind of thing is an X" reports X's own type (subject-side first).
+ *  Miss-only and run AFTER factAnswer returns null, so it never shadows the
+ *  subject-side answer or a schema hit. Returns { text, replace:true } or null. */
+async function factReadBack(memoryDir, query, envelope, miss, graph = null) {
   if (!miss) return null;
   let normFactTerm;
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
   const q = String(query).trim();
-  // The meta form the grammar's T5 template speaks ("what is a Y"), taken from the
-  // parse when present, else recognized directly on a no-parse miss (same required-
-  // article discipline as factAnswer's own meta fallback).
+  const rows = await factRows(memoryDir);
+  if (!rows.length) return null;
+  const isa = rows.filter((f) => ISA_PREDICATES.has(f.predicate));
+  const byTrust = (a, b) => b.trust - a.trust;
+  const renderMany = (hits) => {
+    const shown = hits.slice(0, FACT_ANSWER_CAP).map(renderFactLine);
+    const n = hits.length - FACT_ANSWER_CAP;
+    const extra = n > 0 ? `\n…and ${n} more remembered fact${n === 1 ? "" : "s"}.` : "";
+    return { text: shown.join("\n") + extra, replace: true };
+  };
+
+  // (d) WHOLE-STORE recall (CHATBENCH_006 lever 3) — "what did i tell you last time",
+  // "what facts do you know": no term to bind, so list every remembered fact,
+  // higher-trust first, each cited. Answers the cross-session assert-recall surfaces.
+  if (WHOLE_RECALL_RE.test(q)) {
+    const hits = (isa.length ? isa : rows).slice().sort(byTrust);
+    if (!hits.length) return null;
+    return renderMany(hits);
+  }
+
+  // (a) FORWARD membership — "is an X a Y". X's fact-subject candidates are the
+  // term itself (a class word) AND, when it resolves in the graph, its class-noun
+  // (an instance) — so "is app/lib/a.mjs a component" answers off "module …".
+  const isaAsk = q.match(ISA_ASK_RE);
+  if (isaAsk) {
+    const objVariants = factTermVariants(normFactTerm, isaAsk[2]);
+    const subjCandidates = new Set(factTermVariants(normFactTerm, isaAsk[1]));
+    const noun = await entityClassNoun(graph, isaAsk[1]);
+    if (noun) for (const v of factTermVariants(normFactTerm, noun)) subjCandidates.add(v);
+    const hit = isa
+      .filter((f) => subjCandidates.has(f.subject) && objVariants.has(f.object))
+      .sort(byTrust)[0];
+    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    return null; // no remembered fact — the honest miss stands (never a guessed "no")
+  }
+
+  // (b) RECALL — "what did i tell you about X": every remembered fact mentioning X.
+  const told = q.match(TOLD_ABOUT_RE);
+  if (told) {
+    const variants = factTermVariants(normFactTerm, told[1]);
+    const hits = rows.filter((f) => variants.has(f.subject) || variants.has(f.object)).sort(byTrust);
+    if (!hits.length) return null;
+    const term = variants.has(hits[0].subject) ? hits[0].subject : hits[0].object;
+    const shown = hits.slice(0, FACT_ANSWER_CAP).map((f) => `  ${renderFactLine(f)}`);
+    const extra = hits.length > FACT_ANSWER_CAP ? `\n  …and ${hits.length - FACT_ANSWER_CAP} more.` : "";
+    return { text: `${hits.length} remembered fact${hits.length === 1 ? "" : "s"} about ${term}:\n${shown.join("\n")}${extra}`, replace: true };
+  }
+
+  // (c) REVERSE / "what kind of thing" membership. The meta form ("what is a Y")
+  // comes from the parse when present, else recognized directly on a no-parse miss;
+  // "what kind of thing is an X" is recognized regardless (the grammar never parses
+  // it as meta). "what is a Y" reports Y's MEMBERS (object-side); "what kind of
+  // thing is an X" reports X's own TYPE (subject-side first), so both directions
+  // of a single remembered "X is a kind of Y" are queryable.
   let term = envelope?.parsed?.shape === "meta" ? envelope.parsed.object : null;
-  if (!term && !envelope?.parsed) {
+  let kindOf = false;
+  const mk = q.match(KIND_OF_RE);
+  if (mk) { term = mk[1]; kindOf = true; }
+  else if (!term && !envelope?.parsed) {
     const m = q.match(/^what\s+(?:is|are)\s+an?\s+(.+?)[?.!\s]*$/i);
     if (m) term = m[1];
   }
   if (!term) return null;
   const variants = factTermVariants(normFactTerm, term);
-  const hits = (await factRows(memoryDir))
-    .filter((f) => ISA_PREDICATES.has(f.predicate) && variants.has(f.object))
-    .sort((a, b) => b.trust - a.trust);
+  const subjectHits = isa.filter((f) => variants.has(f.subject)).sort(byTrust);
+  const objectHits = isa.filter((f) => variants.has(f.object)).sort(byTrust);
+  const hits = kindOf
+    ? (subjectHits.length ? subjectHits : objectHits)
+    : (objectHits.length ? objectHits : subjectHits);
   if (!hits.length) return null;
-  const shown = hits.slice(0, FACT_ANSWER_CAP).map(renderFactLine);
-  const n = hits.length - FACT_ANSWER_CAP;
-  const extra = n > 0 ? `\n…and ${n} more remembered fact${n === 1 ? "" : "s"}.` : "";
-  return { text: shown.join("\n") + extra, replace: true };
+  return renderMany(hits);
 }
 
 // ---- W5: corpus on-demand — LOCAL tier only, behind an explicit flag ----
@@ -738,14 +856,45 @@ async function recallSummary(memoryDir) {
   }
 }
 
+/** "[and/so/…] what about X" — a discourse continuation that re-asks the previous
+ *  turn's question with X swapped in. */
+const WHAT_ABOUT_RE = /^(?:(?:and|so|but|ok|okay|now|then)\s+)*what about\s+(.+?)[?.!\s]*$/i;
+/** A code-ish name token in a prior query (a path/dotted name, or a CamelCase/
+ *  Capitalized symbol) — the subject "what about X" replaces. */
+const NAME_TOKEN_RE = /\b[\w-]+(?:[/.][\w-]+)+\b|\b[A-Z][A-Za-z0-9_]*\b/;
+
+/** DISCOURSE CONTINUATION (CHATBENCH_006 lever 2): "what about X" carries the PRIOR
+ *  turn's question shape across the turn boundary — re-asking it with X in place of
+ *  the previous subject/object. Returns the reconstructed query (parsed like any
+ *  subject question, so X resolves and becomes the new focus), or null when there's
+ *  no prior query or no name token to swap (→ the ordinary honest miss stands). */
+function discourseRewrite(query, last) {
+  const m = String(query).match(WHAT_ABOUT_RE);
+  if (!m || !last?.query) return null;
+  const prevQ = String(last.query);
+  if (!NAME_TOKEN_RE.test(prevQ)) return null;
+  const newSubj = m[1].trim();
+  return prevQ.replace(NAME_TOKEN_RE, () => newSubj);
+}
+
 /** A bare question → tmct_ask. When a focus is set AND the graph is in hand we
  *  call ask() directly to thread the focus as contextId (so a pronoun like "it"
  *  resolves to the focus) — building the SAME delimited string dispatchTool emits;
  *  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, templates, memoryDir, env }) {
+async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, env }) {
   const ts = new Date().toISOString();
+  // DISCOURSE ANAPHORA (CHATBENCH_006 levers 1+2): a follow-up like "which of those
+  // are tested" / "how many of those" / "count them" filters or counts the PREVIOUS
+  // answer's entity set. That set is the ids the last dispatched turn cited — carried
+  // on `last.detail.matches`. Threading it as ask()'s `prev` is what lets the anaphora
+  // node resolve instead of the "needs a previous answer" honest miss.
+  const prev = (last?.detail?.matches || []).map((m) => m?.id).filter(Boolean);
+  // The query the ENGINE parses: a "what about X" continuation is rewritten to the
+  // prior shape with X swapped in; everything else parses verbatim. The record and
+  // transcript keep the user's ACTUAL words (`query`), only the parse target changes.
+  const askQuery = discourseRewrite(query, last) ?? query;
   // W2: the explicit recall forms are answered from memory's folded blocks, never
   // the graph. Gated on memoryDir — a bare runTurn (no session shell) stays pure.
   if (memoryDir && RECALL_ASK_RE.test(String(query).trim())) {
@@ -758,12 +907,16 @@ async function runAsk(query, { config, source, graph, focus, templates, memoryDi
   let envelope = null;
   try {
     let text;
-    if (graph && focus?.id) {
+    if (graph && (focus?.id || prev.length)) {
+      // Direct ask() when EITHER a focus is set (thread it as contextId so "it"
+      // binds) OR the previous turn produced a set to refer back to (thread it as
+      // `prev` for the anaphora node). Builds the SAME delimited envelope dispatchTool
+      // emits, so the parse below is identical either way.
       const { ask } = await import("./ask.mjs");
-      const r = ask(graph, query, { contextId: focus.id });
+      const r = ask(graph, askQuery, { contextId: focus?.id ?? null, prev });
       text = `${r.content}${ASK_ENVELOPE_DELIM}${JSON.stringify(r.tmct_ask, null, 2)}`;
     } else {
-      text = await dispatchTool("tmct_ask", { query }, { config, source });
+      text = await dispatchTool("tmct_ask", { query: askQuery }, { config, source });
     }
     const [content, envJson] = text.split(ASK_ENVELOPE_DELIM);
     answer = content;
@@ -800,7 +953,7 @@ async function runAsk(query, { config, source, graph, focus, templates, memoryDi
     // Subject-side facts first (factAnswer), then the reverse-membership read-back
     // (factReadBack) so an asserted "every X is a Y" answers "what is a Y" too.
     const fact = (await factAnswer(memoryDir, query, envelope, miss))
-      ?? (await factReadBack(memoryDir, query, envelope, miss));
+      ?? (await factReadBack(memoryDir, query, envelope, miss, graph));
     if (fact) {
       answer = fact.replace ? fact.text : `${answer}\n${fact.text}`;
       via = "fact";
@@ -992,7 +1145,15 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // Aggregate/count questions are answered mechanically off the loaded graph header,
   // BEFORE falling through to the ask engine (focus unchanged — a count names no entity).
   const count = answerCount(graph, line);
-  if (count != null) return withLast(plainTurn(line, count, { via: "count", focus }));
+  if (count != null) {
+    // An "I can't count <noun>" from a bare kind may still be answerable from an
+    // ASSERTED vocabulary fact ("every class is a type" → "how many types" = the
+    // class count). countFromFacts declines on a real graph kind, so ordinary
+    // counts are unaffected; it only speaks for a remembered object noun.
+    const viaFact = memoryDir ? await countFromFacts(graph, memoryDir, line) : null;
+    if (viaFact != null) return withLast(plainTurn(line, viaFact, { via: "fact", focus }));
+    return withLast(plainTurn(line, count, { via: "count", focus }));
+  }
   return withLast(await runAsk(line, ctx));
 }
 

package/src/grammar/lexicon-core.json

@@ -30,6 +30,14 @@
     "component": {},
     "interface": {},
     "type": {},
+    "category": {},
+    "kind": {},
+    "artifact": {},
+    "routine": {},
+    "part": {},
+    "helper": {},
+    "operation": {},
+    "change": {},
     "schema": {},
     "database": {},
     "table": {},