@polycode-projects/the-mechanical-code-talker 1.8.11 → 1.8.14

package/src/ask.mjs

@@ -62,13 +62,6 @@ import { pickPhrase } from "./answer-variants.mjs";
 
 // Normalization stays importable from its original site (tests + chat surface).
 export { normalizeQuery, applyNegationFrames };
-// The OPTIONAL Node-only wink-nlp adapter (lemma/POS tier). BOUNDARY: the inlined
-// viewer bundle (viz.mjs askSource) strips this import line and never inlines
-// ask-nlp.mjs, so in the browser `nlpAdapter` is simply an undeclared identifier —
-// defaultNlp() below reads it through `typeof`, the one operator that touches an
-// undeclared name without throwing, and the portable single-file HTML degrades to
-// adapter-less parsing (curated tables + bounded fuzzy still on) instead of
-// shipping a ~1MB language model inside the page.
 import { nlpAdapter } from "./ask-nlp.mjs";
 
 /** Per-graph, per-kind memo for THIS file's own edgesOfKind copy — same WeakMap<graph,
@@ -87,15 +80,7 @@ const askEdgesOfKindCache = new WeakMap();
 
 /** All edges of a classified relation kind, flattened across relation groups —
  *  a local copy of codegraph.mjs's private edgesOfKind (kept local rather than
- *  exported+imported to avoid coupling this file's commit boundary to concurrent
- *  in-flight edits elsewhere in codegraph.mjs; both read the same relationKind
- *  classification, so they cannot drift in meaning). Memoized per (graph, kind) —
- *  perf lever, HANDOVER follow-up #8: this is the query engine's hottest path,
- *  called repeatedly on the same (graph, kind) pair across a single query's
- *  compositional evaluation, and at monorepo scale (tens of thousands of modules)
- *  the repeated O(relations) scan is a real latency/GC cost — not a correctness
- *  fix (the stack-overflow bug this file's twin comment references is already
- *  fixed and unrelated). */
+ *  exported+imported to avoid coupling this file's commit. */
 function edgesOfKind(graph, kind) {
   let byKind = askEdgesOfKindCache.get(graph);
   if (!byKind) { byKind = new Map(); askEdgesOfKindCache.set(graph, byKind); }
@@ -145,6 +130,12 @@ const PLURAL_FORMS = {
   // "Change" is ask-vocab.mjs's pseudo-type (a wildcard over the touch traversal's
   // results, never a node class) — it still needs noun forms for zero-hit templates.
   Change: ["change", "changes"],
+  // Memory-graph classes (memory/core.mjs) — real noun forms for the dynamic
+  // class count/list fallback (PLAN_BREADTH_FIRST_NLU.md (d), see
+  // dynamicClassQuery below) so "2 facts." reads naturally instead of falling
+  // back to the generic "2 results.".
+  Fact: ["fact", "facts"], Utterance: ["utterance", "utterances"],
+  Session: ["session", "sessions"], Source: ["source", "sources"], Rule: ["rule", "rules"],
 };
 function nounFor(entityType, n) {
   const [s, p] = PLURAL_FORMS[entityType] || ["result", "results"];
@@ -200,10 +191,7 @@ const LEADING_RELATION_VERB_RE = new RegExp(
 // keeps the winning parse only, byte-identical to the original two-way merge). ----
 
 /** The default lemma/POS adapter: wink-nlp when this is a Node process with the
- *  optional deps installed, null otherwise. BOUNDARY (see the import comment):
- *  the inlined viewer bundle strips the ask-nlp.mjs import, so `nlpAdapter` is
- *  an UNDECLARED identifier there — `typeof` reads it without throwing and the
- *  browser path degrades to no adapter, same parse pipeline otherwise. */
+ *  optional deps installed, null otherwise.. */
 function defaultNlp() {
   return typeof nlpAdapter === "function" ? nlpAdapter() : null;
 }
@@ -312,7 +300,13 @@ export function parseQueryFull(query, { nlp = undefined } = {}) {
 //   {node:"allOfClass", entityType}              — every individual of a class
 //   {node:"reverseSet"|"forwardSet", kind, entityType, inner}  — nested/relative:
 //        the OBJECT (reverse) / SUBJECT (forward) of the outer edge is the id-set
-//        produced by evaluating `inner` (another AST) — two-stage traversal.
+//        produced by evaluating `inner` (another AST) — two-stage traversal. `inner`
+//        is usually a nested relative clause, but {node:"prevSet"} (below) is a
+//        second, discourse-shaped leaf composing with the same union logic.
+//   {node:"prevSet"}                              — the FULL id set of ask()'s own
+//        `prev` (the immediately-preceding list-shaped answer) — a plural pronoun's
+//        ("those"/"them") antecedent, only ever used as reverseSet/forwardSet's
+//        `inner` (see parsePluralAnaphoraObject).
 //   {node:"membership", entityType, term}        — "<entity> of/in <term>"
 //   {node:"qualifier", filters:[word…], inner}   — adjective post-filters on a set
 //   {node:"boolean", entityType, atoms:[{op,kind,ast|filters}…]}  — set algebra
@@ -391,6 +385,7 @@ function parseComposite(text, nlp) {
     || parseFind(w, lc, nlp, 0)
     || parseList(w, lc, nlp, 0)
     || parseNested(w, lc, nlp, 0)
+    || parsePluralAnaphoraObject(w, lc, nlp)
     || parseRelationalOrQualified(w, lc, nlp, 0);
 }
 
@@ -580,6 +575,43 @@ function parseNested(w, lc, nlp, depth) {
   return null;
 }
 
+// PLURAL ANAPHORA OBJECT (HANDOVER.md 2026-07-12 finding: CONTEXT_WORDS/resolveTermOrContext
+// only ever bound a SINGULAR pronoun to ask()'s contextId — "what tests cover those", after a
+// listing turn, fell to an honest miss with the literal word "those" treated as an unresolvable
+// module name). "those"/"them" standing as a BARE pronoun in an ordinary reverse/forward clause
+// ("what tests cover those" — trailing, the reverse OBJECT; "what do those import" — leading, the
+// forward SUBJECT) refer to the FULL id set of the immediately-preceding list-shaped answer —
+// exactly the id array ask()'s own `prev` already threads for parseAnaphora's "of those"/"count
+// them" shapes. Reuses reverseSet/forwardSet's existing multi-object UNION traversal (parseNested,
+// just above) verbatim: the only new thing is a second kind of `inner` leaf, {node:"prevSet"},
+// that reads `prev` instead of evaluating a nested clause.
+//
+// Two positions are recognized, both requiring the pronoun to stand ALONE (never a determiner —
+// "list those functions" is untouched): the sentence's FINAL word (mirrors parseAnaphora's own
+// "count them"/"list them" terminal pinning — the reverse-clause object trails its verb), or
+// immediately followed by a known relation verb (the forward-clause subject leads its verb: "those
+// IMPORT" is unambiguously a pronoun-then-verb, never "those <noun>"). An "of those"/"of them"
+// tail is parseAnaphora's own territory (checked earlier in parseComposite) and is skipped here.
+// After the substitution, `outer.object` is verified to BE the sentinel itself — guards against a
+// keyword-spot retry silently resolving the object to some other word in the sentence instead.
+const PLURAL_ANAPHORA_OBJECT = new Set(["those", "them"]);
+function parsePluralAnaphoraObject(w, lc, nlp) {
+  for (let i = 0; i < lc.length; i += 1) {
+    if (!PLURAL_ANAPHORA_OBJECT.has(lc[i])) continue;
+    if (lc[i - 1] === "of") continue; // "…of those/them" — parseAnaphora's own shape
+    const isTerminal = i === lc.length - 1;
+    const leadsAVerb = i + 1 < lc.length && !!VERB_TO_KIND[lc[i + 1]];
+    if (!isTerminal && !leadsAVerb) continue; // a determiner use ("those functions") — not a bare pronoun
+    const head = [...w.slice(0, i), NEST_SENTINEL, ...w.slice(i + 1)];
+    const outer = parseSimpleClause(head.join(" "), nlp);
+    if (!outer || (outer.shape !== "reverse" && outer.shape !== "forward")) continue;
+    if (outer.object !== NEST_SENTINEL) continue;
+    if (outer.modifier && outer.modifier !== "direct") continue; // no transitive-over-set closure primitive
+    return { node: outer.shape === "reverse" ? "reverseSet" : "forwardSet", kind: outer.kind, entityType: outer.entityType, inner: { node: "prevSet" } };
+  }
+  return null;
+}
+
 // TEMPORAL-OVER-RELATIVE (Phase 11 Track 1, lever 3) — "when did <relative set> [last]
 // change". The flat when-shape (traverse) dates the commits touching ONE resolved term;
 // this composes that same touches→commit→date-sort machinery as an OUTER operator over a
@@ -1571,9 +1603,23 @@ function membershipOwnSet(graph, id, entityType) {
  *  path prefix with no exact node of its own — see directoryScopeModules's own
  *  doc) or a single container individual, exactly like the "membership" case's own
  *  pre-item-6 resolution — extracted unchanged so evalSet's plain path and the
- *  composite/disclosure path (evalMembershipComposite) can never drift. */
-function resolveMembershipOwner(graph, term) {
-  const r = resolveObject(graph, term);
+ *  composite/disclosure path (evalMembershipComposite) can never drift.
+ *
+ *  `contextId` (HANDOVER.md 2026-07-12 finding, fast-loop round 4): this used to
+ *  call bare `resolveObject(graph, term)` with no context-pronoun notion at all —
+ *  "methods of that"/"attributes of it" reached resolveObjectCore's ordinary
+ *  mechanical tiers with the raw pronoun string, an honest miss at best and, at
+ *  worst, a false-positive substring hit (a 2-4 letter pronoun is a near-certain
+ *  accidental substring of SOME real label — the exact
+ *  STACCATO_LEAKED_CONNECTIVES trap chat.mjs documents for "it"/"and"). Routed
+ *  through resolveTermOrContext instead — the SAME contextId-aware resolution
+ *  evalQualCheck and traverse()'s reverse/forward shapes already use for
+ *  subject-/object-position pronouns — so a pronoun binds to the standing focus
+ *  and a non-pronoun term resolves byte-identically to before (resolveTermOrContext
+ *  falls through to the same bare `resolveObject` call for anything that isn't a
+ *  CONTEXT_PRONOUNS member). */
+function resolveMembershipOwner(graph, term, contextId = null) {
+  const r = resolveTermOrContext(graph, term, contextId);
   if (!(r.match && r.tier === 1)) {
     const dirMods = directoryScopeModules(graph, term);
     if (dirMods.length) return { kind: "dir", mods: dirMods };
@@ -1842,6 +1888,15 @@ function evalSet(graph, ast, opts) {
       const ids = new Set(evalSet(graph, ast.inner, opts).map((i) => i.id));
       return forwardOverSet(graph, ast.kind, ids);
     }
+    // the previous list-shaped answer's own id set (parsePluralAnaphoraObject's
+    // "those"/"them" leaf) — evalComposite's reverseSet/forwardSet dispatch already
+    // intercepts the genuinely-empty (no `prev` at all) case as an honest "needs a
+    // previous answer" miss, same as evalAnaphora's own no-prev branch; this is only
+    // reached with a real, non-empty `prev` in hand.
+    case "prevSet": {
+      const prev = opts && opts.prev;
+      return Array.isArray(prev) ? prev.map((id) => graph.byId.get(id)).filter(Boolean) : [];
+    }
     case "membership": {
       // DIRECTORY SCOPE ("modules in src/lib", "files in src/handlers"): a bare
       // path term with no exact node of its own is a DIRECTORY, not a single
@@ -1854,7 +1909,7 @@ function evalSet(graph, ast, opts) {
       // node match (tier 1 — a real file/symbol named that) still wins outright
       // (unchanged single-container-node behavior, e.g. "methods in widget.mjs");
       // only when there is no exact match do we try directory-prefix scope first.
-      const owner = resolveMembershipOwner(graph, ast.term);
+      const owner = resolveMembershipOwner(graph, ast.term, opts && opts.contextId);
       if (owner.kind === "dir") {
         if (!ast.entityType || ast.entityType === "Module") return owner.mods;
         const ids = new Set(owner.mods.map((m) => m.id));
@@ -1977,8 +2032,14 @@ function evalAnaphora(graph, ast, opts) {
 // commit-history kinds are excluded so "connections" reads as the code-structure
 // degree a developer means, not every recorded touch.
 const DEGREE_KINDS = ["imports", "calls", "callsSymbol", "inherits", "contains", "tests"];
-/** Degree of an individual under a superlative metric ({kind, dir, sibling?, filter?}). */
-function degreeMetric(graph, ind, metric) {
+/** Degree of an individual under a superlative metric ({kind, dir, sibling?, filter?}).
+ *  Exported (2026-07-12, HANDOVER "bare 'how many X' fails for edge-nominalized
+ *  nouns" fix) so chat.mjs's answerEdgeCount can compute the SAME per-entity
+ *  degree for a single named entity ("how many callers does X have") that this
+ *  file's own evalSuperlative already uses to rank every entity of a class
+ *  ("which module has the most callers") — one metric definition
+ *  (EDGE_NOUN_TO_METRIC), one degree computation, two call sites. */
+export function degreeMetric(graph, ind, metric) {
   const kinds = metric.kind === "*" ? DEGREE_KINDS : [metric.kind, ...(metric.sibling ? [metric.sibling] : [])];
   let n = 0;
   for (const k of kinds) for (const e of edgesOfKind(graph, k)) {
@@ -2088,7 +2149,7 @@ function evalMembershipComposite(graph, ast, opts) {
   const filterFn = qualNode
     ? (ind) => qualNode.filters.every((f) => qualHolds(graph, ind, QUALIFIERS[f]))
     : null;
-  const owner = resolveMembershipOwner(graph, memNode.term);
+  const owner = resolveMembershipOwner(graph, memNode.term, opts && opts.contextId);
   if (owner.kind === "dir") {
     let objs;
     if (!entityType || entityType === "Module") objs = owner.mods;
@@ -2187,6 +2248,14 @@ export function evalComposite(graph, ast, opts = {}) {
       matches: narrow.length ? narrow : broad, broad: !narrow.length && broad.length > 0,
     };
   }
+  // plural-anaphora object (parsePluralAnaphoraObject): a genuinely EMPTY `prev` means
+  // "those"/"them" has no antecedent at all — the same honest "needs a previous answer"
+  // miss evalAnaphora's own no-prev branch gives "of those"/"count them", rather than
+  // evalSet's ordinary (and here misleading) empty-set "nothing in the index matches".
+  if ((ast.node === "reverseSet" || ast.node === "forwardSet") && ast.inner.node === "prevSet"
+    && !(Array.isArray(opts.prev) && opts.prev.length)) {
+    return { compositeMiss: true, reason: "no-prev", matches: [] };
+  }
   return { compositeKind: "set", matches: evalSet(graph, ast, opts), entityType: ast.entityType || null };
 }
 
@@ -2276,7 +2345,10 @@ function renderComposite(parsed, result) {
     // an unscoped list that overflowed the cap gets a light hint to narrow by module —
     // but only for kinds that live IN a module (a "modules in <module>" or "commits in
     // <module>" scope is meaningless); the scoped forms are already narrow, no hint.
-    const scopeable = !["Module", "Commit"].includes(result.entityType);
+    // Memory-graph classes (Fact/Utterance/Session/Source/Rule, dynamicClassQuery
+    // above) never support a module scope either — there's no such parse for them —
+    // so they're excluded here too rather than hinting at an unsupported shape.
+    const scopeable = !["Module", "Commit", "Fact", "Utterance", "Session", "Source", "Rule"].includes(result.entityType);
     const hint = (!result.scoped && scopeable && result.matches.length > OVERFLOW_CAP)
       ? ` — narrow with "${nounFor(result.entityType, 2)} in <module>"`
       : "";
@@ -3426,7 +3498,24 @@ export function traverse(graph, parsed, { contextId = null, prev = null, pinnedO
         widenNote = `, widened to ${siblingClass} subjects (no ${entityType} recorded)`;
       }
     }
-    return { matches, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}${widenNote}`, ambiguous, matchedVia };
+    // "touches" up-refine composability (HANDOVER 2026-07-12, Class-to-module
+    // up-refinement): an EMPTY touchesSymbol lookup on a resolved CLASS is not
+    // decisive the way it is for a Function/Method — a Class reads naturally as
+    // "the file/unit that holds it", so "who touched <Class>" with no recorded
+    // symbol-precise touch should still answer from the class's containing
+    // module's real touches, rather than a confident-looking-but-possibly-wrong
+    // "nothing touched it". Fall through to the grain-aware up-refine below
+    // ONLY for that Class case. Deliberately NOT widened to every
+    // FINE_ENTITY_TYPES member: "how many commits touched fnAlpha" (a Function)
+    // is pinned elsewhere (ask-combo.test.mjs's grain-aware COUNT lever) to stay
+    // an honest 0 rather than a module-grain false hit — symbol-level counting
+    // precision for functions/methods is a deliberate, separate guarantee this
+    // change must not erode. `calls` is untouched either way: an empty
+    // callsSymbol result stays decisive (call parsing isn't a best-effort
+    // heuristic the way commit-diff symbol attribution is).
+    if (matches.length || !(kind === "touches" && objMatch.class === "Class")) {
+      return { matches, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}${widenNote}`, ambiguous, matchedVia };
+    }
   }
 
   // §grain-aware object resolution (Bug C+D, HANDOVER follow-up #2, checked BEFORE
@@ -3457,13 +3546,23 @@ export function traverse(graph, parsed, { contextId = null, prev = null, pinnedO
       gCandidates = retry.candidates;
       gAmbiguous = retry.ambiguous;
       gMatchedVia = retry.matchedVia;
-    } else if ((kind === "tests" || kind === "cochange") && gObjMatch.class !== "Module") {
-      // (2) tests/cochange are always Module->Module — no same-grain alternative
-      // exists (the retry above genuinely found nothing), but the resolved
-      // fine-grain entity (a Function, say) DOES live in a module, and that
-      // module is the real, honest subject of a tests/cochange question ("does
-      // createTask have tests" — fixes Bug D). Up-refine via the same moduleIdOf
-      // qualHolds's "tested" case already uses (see its divergence comment above).
+    } else if (wantClass === "Module") {
+      // (2) up-refine to the containing module — driven by kindObjectClass
+      // itself (any kind whose real object-class is ALWAYS Module: tests,
+      // cochange, imports, touches, …), not a hardcoded kind name list, so a
+      // kind newly recorded as Module->Module in the graph gets this for free.
+      // No same-grain alternative exists here (the retry above genuinely found
+      // nothing), but the resolved fine-grain entity (a Function/Class, say)
+      // DOES live in a module, and that module is the real, honest subject of
+      // the question ("does createTask have tests" — Bug D; "who touched Bar",
+      // "what modules import Bar" — the same up-refine extended past
+      // tests/cochange, HANDOVER 2026-07-12). `calls` computes to Module here
+      // too, but never actually reaches this branch with a wrong-grain object:
+      // the symbolKind branch above already intercepts every Class/Function/…
+      // object for `calls` unconditionally (its empty-result IS decisive, see
+      // that branch's own comment), so this is inert-but-correct for it. Up-
+      // refine via the same moduleIdOf qualHolds's "tested" case already uses
+      // (see its divergence comment above).
       const mid = moduleIdOf(graph, gObjMatch);
       const mod = mid && graph.byId.get(mid);
       if (mod) {
@@ -4365,6 +4464,72 @@ function substituteLastCommitPhrase(graph, query) {
   return BARE_WHEN_COMMIT_RE.test(bareTrimmed) ? `${bareTrimmed} touched` : out;
 }
 
+// ---- dynamic memory-graph class count/list (PLAN_BREADTH_FIRST_NLU.md (d),
+// ROADMAP.md "What's next" (d)): a real "list/count all X of class Y" shape for
+// MEMORY-graph classes (Fact/Utterance/Session/Source/Rule, or any class a taught
+// individual actually carries), reachable via ask.mjs alone — the gap live-testing
+// during the viz chat panel's build confirmed ("how many facts are there"/"list
+// facts"/"what is a Fact" all missed against a real memory graph, since the only
+// working machinery for this shape lived in chat.mjs's heavier factAnswer cascade,
+// out of the browser bundle's ask.mjs-only scope).
+//
+// ENTITY_TO_TYPE (ask-vocab.mjs) is a CLOSED table of code-graph nouns only
+// (module/function/class/…) — memory-graph classes are open-ended (taught, not a
+// fixed vocabulary), so they can't be added to that table the same way. Instead,
+// this resolves the noun against whatever classes ACTUALLY have at least one
+// individual in THIS graph right now (never guesses a class exists with zero
+// evidence — same zero-fabrication discipline as everything else here) and
+// reuses the exact SAME count/list AST + traverse()+render() path every
+// code-graph count/list query already runs through (evalComposite's
+// "allOfClass"/"count"/"list" nodes, already generic over any `individual.class`
+// string — see `evalSet`'s "allOfClass" case and renderComposite's "count"/"list"
+// branches above) — no new render logic, no new miss/hit wording invented.
+//
+// Fires ONLY as a fallback in ask() after the normal cascade already produced an
+// honest miss, and is skipped entirely for any noun ENTITY_TO_TYPE already owns
+// (so a real code-graph "list modules"/"how many classes" answer, including its
+// own honest empty-graph miss wording, is never intercepted or changed).
+function singularCandidates(word) {
+  const w = String(word || "").toLowerCase();
+  const c = new Set([w]);
+  if (w.endsWith("ies")) c.add(`${w.slice(0, -3)}y`);
+  if (w.endsWith("ses")) c.add(w.slice(0, -2));
+  else if (w.endsWith("es")) c.add(w.slice(0, -2));
+  if (w.endsWith("s") && w.length > 1) c.add(w.slice(0, -1));
+  return [...c];
+}
+function resolveDynamicClass(graph, word) {
+  const cands = singularCandidates(word);
+  for (const ind of graph?.individuals || []) {
+    if (ind?.class && cands.includes(String(ind.class).toLowerCase())) return ind.class;
+  }
+  return null;
+}
+const DYNAMIC_LIST_TRIGGER_RE = /^(?:list|show(?:\s+me)?)\s+(?:all\s+|the\s+)?([a-z][a-z'-]*)\s*(.*)$/i;
+const DYNAMIC_COUNT_TRIGGER_RE = /^(?:how\s+many|number\s+of|count(?:\s+the)?)\s+([a-z][a-z'-]*)\s*(.*)$/i;
+// A closed set of harmless trailing fillers ("are there", "do you know", …) — an
+// empty tail is the plain "list facts"/"how many facts" shape; anything else
+// (a real restrictor like "that mention X") is NOT this shape and is left alone
+// so it stays whatever honest miss the normal cascade already produced.
+const DYNAMIC_TAIL_OK_RE = /^(?:are there(?:\s+in\s+total)?|is there|do you know(?:\s+about)?|do you have|exist(?:s)?|are known|in (?:the |a )?(?:graph|memory)|you know(?:\s+about)?)?[?.!\s]*$/i;
+
+/** Compile "list/how many <memory-class-noun>" into the same count/list AST every
+ *  code-graph count/list query already builds, or null when this isn't that shape
+ *  (wrong trigger, a real restrictor tail, ENTITY_TO_TYPE already owns the noun, or
+ *  no individual in THIS graph actually carries that class). */
+function dynamicClassQuery(graph, query) {
+  const q = String(query || "").trim();
+  const listM = q.match(DYNAMIC_LIST_TRIGGER_RE);
+  const countM = !listM ? q.match(DYNAMIC_COUNT_TRIGGER_RE) : null;
+  const m = listM || countM;
+  if (!m || !DYNAMIC_TAIL_OK_RE.test(m[2] || "")) return null;
+  if (ENTITY_TO_TYPE[m[1].toLowerCase()]) return null;
+  const entityType = resolveDynamicClass(graph, m[1]);
+  if (!entityType) return null;
+  const base = { node: "allOfClass", entityType };
+  return listM ? { node: "list", entityType, base, scoped: false } : { node: "count", entityType, base };
+}
+
 export function ask(graph, query, { contextId = null, nlp = undefined, prev = null } = {}) {
   // Explicit help/orientation request → the rephrase hint directly (the honest bottom
   // of the cascade, reached on demand), never a pretend answer or a relaxation attempt.
@@ -4394,8 +4559,21 @@ export function ask(graph, query, { contextId = null, nlp = undefined, prev = nu
     const r = relaxParse(graph, query, { nlp, contextId, prev });
     if (r) { parsed = r.parsed; relaxed = { from: r.from, to: r.to, dropped: r.dropped, steps: r.steps }; }
   }
-  const result = traverse(graph, parsed, { contextId, prev });
-  const rendered = render(parsed, result);
+  let result = traverse(graph, parsed, { contextId, prev });
+  let rendered = render(parsed, result);
+  // Dynamic memory-graph class count/list fallback (PLAN_BREADTH_FIRST_NLU.md (d))
+  // — fires ONLY once everything above already produced an honest miss, and only
+  // replaces it when the fallback itself produces a real (non-miss) answer, so a
+  // genuine "no X in this index" miss for an ENTITY_TO_TYPE-owned noun is never
+  // touched (dynamicClassQuery declines those itself — see its own doc above).
+  if (rendered.miss && !rendered.ambiguous) {
+    const dyn = dynamicClassQuery(graph, query);
+    if (dyn) {
+      const dynResult = traverse(graph, dyn, { contextId, prev });
+      const dynRendered = render(dyn, dynResult);
+      if (!dynRendered.miss) { parsed = dyn; result = dynResult; rendered = dynRendered; relaxed = null; }
+    }
+  }
   // If relaxation materially rewrote the query and produced a real answer, note it
   // lightly (terse, honest) so the reader knows how the question was read.
   let content = (relaxed && !rendered.miss && relaxed.to !== relaxed.from)