@polycode-projects/the-mechanical-code-talker 1.8.10 → 1.8.12

package/README.md

@@ -360,8 +360,8 @@ on the chat's hot path.
 ## What tmct deliberately is NOT
 
 - **It is not an indexer.** tmct keeps no codebase index of its own. It
-  consumes a graph via a provider seam (`fetchEntities` and friends); producing
-  a code graph is out of scope. tmct's job is the *conversation*.
+  consumes a graph via a provider seam (`fetchEntities` and friends) — building
+  that graph is a different tool's job. 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"). It is deterministic, explainable, and cheap. Even its forward-chaining

package/ROADMAP.md

@@ -18,8 +18,9 @@ Declared, forward-looking goals — not yet achieved, stated here so they steer
 getting silently traded away by inherited caution:
 
 - **Reach for Llama-3-level natural language fluency.** Not by putting an LLM in the product path
-  (still permanent, see "Explicitly out of scope") — by growing rich template/surface-realization
-  variety, so an answer shape has many valid phrasings instead of one fixed slot-fill.
+  (tmct will never do that — see "What tmct will never do"). Instead, by growing rich
+  template/surface-realization variety, so an answer shape has many valid phrasings instead of one
+  fixed slot-fill.
 - **Resolve ambiguity breadth-first, always.** Every genuinely valid reading gets its own real answer
   restated in full, never a bare "could mean X or Y — try rephrasing" punt, bounded only by existing
   clipping/pagination limits. Landed for both ambiguity shapes tmct has: parse-level ties
@@ -219,11 +220,13 @@ original question, citing what was just learned. Strictly opt-in, offline defaul
 Prerequisites: the provenance-trust policy must extend to `via:"learned:web"`, never silently
 blending web-sourced facts with graph/operator facts.
 
-## Explicitly out of scope
+## What tmct will never do
 
-- No AWS, no benchmark rig — a published npm library + CLI with a static GitLab Pages home page only.
-- No auto-publish — a version release is gated on a deliberate version-bump commit.
-- No MCP server, no LLM in the product path — permanent, not "for now."
+- Run on AWS or maintain a benchmark rig — tmct is a published npm library + CLI with a static
+  GitLab Pages home page, nothing more.
+- Publish automatically — a version release always requires a deliberate version-bump commit.
+- Run an MCP server or put an LLM in the product path — a core identity decision, decided once,
+  not revisited.
 
 ## Design docs
 

package/package.json

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

@@ -1571,9 +1571,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 };
@@ -1854,7 +1868,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 +1991,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 +2108,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;
@@ -3426,7 +3446,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 +3494,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) {

package/src/chat.mjs

@@ -57,7 +57,7 @@ import { rankByBiasThenTrust } from "./memory/bias.mjs";
 import { finish, beginsWithVowelSound, grammarRules } from "./finish.mjs";
 import {
   VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE, PASSIVE_PARTICIPLE_TO_KIND,
-  stripTrailingScopeFiller, stripTrailingDiscourseTag,
+  stripTrailingScopeFiller, stripTrailingDiscourseTag, EDGE_NOUN_TO_METRIC, RELATIONS,
 } from "./ask-vocab.mjs";
 import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, normalizeQuery, escapeRegex, kindNounAnaphoraHint } from "./interpret/normalize.mjs";
 import { fuzzyMatchInSet, fuzzyBound } from "./interpret/fuzzy.mjs";
@@ -564,6 +564,113 @@ export function answerCount(graph, query) {
   return `${n} ${classNoun(cls, n)}.`;
 }
 
+/** singular+plural display forms for the edge-nominalized nouns answerEdgeCount
+ *  (below) actually answers — a small subset of EDGE_NOUN_TO_METRIC's keys, the
+ *  ones that read as a real countable noun ("3 callers.") rather than a
+ *  participle only natural in a superlative ("most USED", not "how many used").
+ *  A key with no entry here echoes the user's own word unchanged (safe default,
+ *  same fallback CLASS_LABELS/classNoun use above). */
+const EDGE_NOUN_LABELS = {
+  test: ["test", "tests"], tests: ["test", "tests"],
+  importers: ["importer", "importers"], dependents: ["dependent", "dependents"],
+  callers: ["caller", "callers"], callees: ["callee", "callees"],
+  calls: ["call", "calls"], imports: ["import", "imports"],
+  dependencies: ["dependency", "dependencies"], members: ["member", "members"],
+  subclasses: ["subclass", "subclasses"], connections: ["connection", "connections"],
+  edges: ["edge", "edges"],
+};
+const edgeCountNoun = (noun, n) => {
+  const [s, p] = EDGE_NOUN_LABELS[noun] || [noun, noun];
+  return n === 1 ? s : p;
+};
+
+/** Pull the named entity out of a per-entity edge-count tail — the text after
+ *  "how many <edge-noun>" — recognising exactly the two closed shapes such a
+ *  tail actually takes:
+ *    - "<verb> <entity>" ("cover src/x.mjs", "import Widget") — verb drawn
+ *      from ask-vocab.mjs's RELATIONS[metric.kind].verbs (the SAME verb list
+ *      the relation clause grammar itself reads), longest-first so a
+ *      multi-word verb ("depends on") matches whole rather than a short
+ *      prefix stealing part of the entity name.
+ *    - "does/do/did <entity> have/has/had/got" ("does X have") — safe to
+ *      treat as unambiguous HERE even though answerCount's own
+ *      AMBIGUOUS_HAVE_VERBS guard deliberately excludes "have" elsewhere:
+ *      that guard exists because "have" maps to either defines/contains
+ *      depending on the SUBJECT's class, but an edge-nominalized noun's
+ *      metric.dir is fixed by the NOUN itself ("importers" is always dir
+ *      "in"), so there is no analogous ambiguity to worry about here.
+ *  Returns the trimmed entity term, or null (no recognizable shape — an
+ *  honest decline, not a guess) — the caller then leaves the existing "I
+ *  can't count" message from answerCount standing. */
+function extractEdgeCountEntity(tail, metric) {
+  const t = String(tail || "").trim().replace(/[?.!]+$/, "").trim();
+  if (!t) return null;
+  const haveM = t.match(/^(?:does|do|did)\s+(.+?)\s+(?:have|has|had|got)$/i);
+  if (haveM && haveM[1].trim()) return haveM[1].trim();
+  if (metric.kind !== "*" && RELATIONS[metric.kind]) {
+    const verbs = [...RELATIONS[metric.kind].verbs].sort((a, b) => b.length - a.length);
+    for (const v of verbs) {
+      const re = new RegExp(`^${v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s+(.+)$`, "i");
+      const m = t.match(re);
+      if (m && m[1].trim()) return m[1].trim();
+    }
+  }
+  return null;
+}
+
+/** Bare "how many <edge-noun> <verb> <entity>" / "how many <edge-noun> does
+ *  <entity> have" (HANDOVER "bare 'how many X' fails for edge-nominalized
+ *  nouns", 2026-07-12 fix) — "how many tests cover X", "how many importers
+ *  does X have", "how many callers does X have". answerCount's own COUNT_NOUNS
+ *  table only maps a counted noun to a graph INDIVIDUAL CLASS (Module/Class/…);
+ *  an edge-nominalized noun like "tests"/"importers"/"callers" names an EDGE
+ *  KIND instead — ask-vocab.mjs's EDGE_NOUN_TO_METRIC, the SAME table the
+ *  working superlative lane ("which module has the most tests") already reads
+ *  — so it was never in COUNT_NOUNS and answerCount short-circuited straight
+ *  to "I can't count 'tests'" without ever consulting that table. This reuses
+ *  the SAME per-entity degree computation the superlative lane's own
+ *  evalSuperlative uses to rank every entity of a class (ask.mjs's
+ *  degreeMetric, exported for exactly this) — just read for the ONE named
+ *  entity instead of sorting all of them.
+ *
+ *  Checked BEFORE answerCount in runTurn (same precedence pattern as
+ *  answerMemoryCount/answerQuantifierRecall above) so it gets first look;
+ *  declines (returns null, letting answerCount's existing message stand)
+ *  whenever:
+ *    - the noun isn't edge-nominalized at all (a COUNT_NOUNS class, or truly
+ *      unknown), or
+ *    - no entity term could be extracted from the tail
+ *      (extractEdgeCountEntity), or
+ *    - the extracted term doesn't resolve to exactly one graph entity.
+ *
+ *  SCOPED to the per-entity case only: a bare "how many tests are there" (no
+ *  named entity in the tail) has nothing for extractEdgeCountEntity to pull
+ *  out, so it declines here and keeps answerCount's existing "I can't count
+ *  'tests'" honest miss — what a GLOBAL edge count would even mean (every
+ *  test edge in the graph? distinct test modules? distinct tested modules?)
+ *  is a genuine, undecided design question, out of this fix's scope. */
+async function answerEdgeCount(graph, query) {
+  if (!graph) return null;
+  const q = String(query);
+  if (ANAPHORA_COUNT_RE.test(q) || IMPLICIT_ANAPHORA_COUNT_RE.test(q.trim())) return null;
+  const m = q.match(/\b(?:how many|number of|count(?:\s+the)?)\s+([a-z]+)\b/i);
+  if (!m) return null;
+  const noun = m[1].toLowerCase();
+  if (COUNT_NOUNS[noun]) return null; // a real graph class — answerCount owns it
+  const metric = EDGE_NOUN_TO_METRIC[noun];
+  if (!metric) return null; // not edge-nominalized either — answerCount's "I can't count" stands
+  const term = extractEdgeCountEntity(q.slice(m.index + m[0].length), metric);
+  if (!term) return null; // no per-entity phrasing recognized — scoped out (see docblock)
+  const entity = await resolveEntity(graph, term);
+  if (!entity) return null; // unresolved/ambiguous entity — honest decline, not a guess
+  const ind = graph.byId?.get?.(entity.id);
+  if (!ind) return null;
+  let degreeMetric;
+  try { ({ degreeMetric } = await import("./ask.mjs")); } catch { return null; }
+  const n = degreeMetric(graph, ind, metric);
+  return `${n} ${edgeCountNoun(noun, 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.
@@ -869,6 +976,29 @@ export function isConversational(query) {
   return q.split(/\s+/).filter(Boolean).length <= 3 && !codeish;
 }
 
+/** Scoped exemption for the bare-meta-fact lane (2b/2c, further down this file)
+ *  ONLY — never a change to looksCodeish()/isConversational() themselves, and
+ *  never used for the generic orientation-card fallback. HANDOVER.md 2026-07-12
+ *  finding: a bare "what is TaskController?" (CamelCase COMPOUND class name, no
+ *  article) hits looksCodeish()'s `/[a-z][A-Z]/` branch, so isConversational()
+ *  returns false and the whole isConversationalCandidate gate — including the
+ *  bare-meta-fact lookup that "what is a TaskController" (articled, via its own
+ *  T5 structural parse) already resolves through — never runs. Single-word/
+ *  lowercased names ("Widget", "taskcontroller") have no lowercase-to-uppercase
+ *  transition so they were never affected; only two-word-shaped compounds were.
+ *  This re-tests the SAME non-CamelCase codeish reasons (paths, dotted refs,
+ *  `()` calls, STRUCT_WORDS) looksCodeish already covers, so a genuine near-miss
+ *  structural question ("what is foo.bar()", "what is import") is UNCHANGED —
+ *  still excluded here, still falls through to its existing (better) miss
+ *  handling, never the friendly orientation card. */
+function isBareCamelCaseMetaQuestion(query) {
+  const raw = String(query).trim();
+  const q = raw.toLowerCase().replace(/[.!?]+$/, "").trim();
+  const nonCamelCodeish = /[_./]|\(\)/.test(raw) || q.split(/\s+/).some((w) => STRUCT_WORDS.has(w));
+  if (nonCamelCodeish || q.split(/\s+/).filter(Boolean).length > 3) return false;
+  return BARE_WHATIS_RE.test(raw) || IS_ADJECTIVE_YESNO_RE.test(raw);
+}
+
 // ---- the response-template library (W1: templates → render path) ----
 // The WORDING of the conversational/orientation surfaces lives in
 // data/templates/responses.jsonl (corpus/templates.mjs) — the template library is
@@ -3076,7 +3206,17 @@ async function memorySummary(memoryDir, graph) {
 // both already exist. CASE-PRESERVING: module paths/symbol names are
 // case-sensitive, so this reads the ORIGINAL query text, never metaLane's
 // lowercased `q` (authorLane's same discipline, just above/below).
-const MODULE_ORIENT_RE = /^what\s+does\s+(.+?)\s+do\??$/i;
+/** A trailing intensifier/filler adverb tacked onto "do"/"does" ("what does the
+ *  store module do exactly?", "...do exactly", "what X does really") — fast
+ *  loop round 8 (ESL/filler-phrasing angle): the closed-form anchor below used
+ *  to require "do"/"does" to be the LAST word before the optional "?", so this
+ *  one extra word past it hit the raw grammar wall even though the shared
+ *  FILLER_WORDS/normalizeQuery pass (used elsewhere in the file) never sees
+ *  this lane's case-preserving text at all. Mirrors MODULE_ORIENT_POLITENESS_RE
+ *  just below: closed, optional, single-lane blast radius — a bare "what does
+ *  X do" still matches with this suffix empty. */
+const TRAILING_ADVERB_RE = "(?:\\s+(?:exactly|really|actually|anyway))?";
+const MODULE_ORIENT_RE = new RegExp(`^what\\s+does\\s+(.+?)\\s+do${TRAILING_ADVERB_RE}\\??$`, "i");
 /** The SUBJECT-FIRST word order of the SAME question ("what saveStore does" vs
  *  "what does saveStore do") — Tier 6 playtest, §3b surface-variation axis: a
  *  perfectly natural alternate phrasing of an ALREADY-recognized intent that
@@ -3086,7 +3226,7 @@ const MODULE_ORIENT_RE = /^what\s+does\s+(.+?)\s+do\??$/i;
  *  UNIQUE graph entity or this lane declines) is what keeps this loose an
  *  ending safe — a syntactic match against a term that isn't a real entity
  *  simply falls through unchanged, same as every other lane in this file. */
-const MODULE_ORIENT_SVO_RE = /^what\s+(.+?)\s+does\??$/i;
+const MODULE_ORIENT_SVO_RE = new RegExp(`^what\\s+(.+?)\\s+does${TRAILING_ADVERB_RE}\\??$`, "i");
 // Seonix Batch 3 (3a) — purpose/identity phrasing: "whats X for"/"what's X
 // about"/"what is X for", the sibling of "what does X do" that asks for the
 // SAME module-grain overview. Deliberately does NOT claim the literal noun
@@ -7209,7 +7349,8 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       } catch { /* leave false — the ordinary path decides */ }
     }
   }
-  const isConversationalCandidate = !handled && miss && !envelope?.parsed && isConversational(query) && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus;
+  const conversationalCandidateBaseGate = !handled && miss && !envelope?.parsed && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus;
+  const isConversationalCandidate = conversationalCandidateBaseGate && isConversational(query);
   // BUG 2 fix (2026-07-09): "what is X" with NO article ("what is john") is BOTH
   // conversational-shaped (≤3 words, no code-ish token — isConversational() would
   // claim it) AND a legitimate bare meta/fact-lookup form (BARE_WHATIS_RE —
@@ -7240,8 +7381,20 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // 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());
+  // 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"
+  // (CamelCase compound, no article) is otherwise excluded solely because
+  // isConversational()'s codeish check fires on the CamelCase transition, even
+  // though every other precondition (miss, no structural parse, no continuation
+  // in flight) already holds. Shares the SAME base gate as isConversationalCandidate
+  // (conversationalCandidateBaseGate) so it's never looser. Scoped to this `if`
+  // 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);
   let bareMetaHit = null;
-  if (isConversationalCandidate && (bareWhatisShape || isAdjectiveShape)) {
+  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));
@@ -8282,6 +8435,19 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
       return withLast(plainTurn(workingLine, quantifierRecall, { via: "fact", focus }), "recall a taught quantifier");
     }
   }
+  // Edge-nominalized "how many X" counts ("how many tests cover Y", "how many
+  // callers does Y have") — checked BEFORE answerCount (same precedence
+  // pattern as answerQuantifierRecall/answerMemoryCount above): answerCount's
+  // own COUNT_NOUNS table doesn't know these nouns at all and would otherwise
+  // short-circuit straight to "I can't count 'tests'" before this lane ever
+  // got a turn. Declines (null) for anything answerCount should own, or a bare
+  // global count with no named entity — see answerEdgeCount's own docblock.
+  const edgeCount = await answerEdgeCount(graph, workingLine);
+  if (edgeCount != null) {
+    note(trace, 'goal: get a per-entity count of an edge-nominalized kind ("how many tests cover X", "how many callers does X have")');
+    note(trace, "lane: answerEdgeCount — matched an EDGE_NOUN_TO_METRIC noun with a resolvable named entity, answered via the same degreeMetric the superlative lane uses");
+    return withLast(plainTurn(workingLine, edgeCount, { via: "count", focus }), "get a per-entity edge count");
+  }
   // 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, workingLine);