@polycode-projects/the-mechanical-code-talker 1.9.1 → 1.10.0

package/src/interpret/pipeline.mjs

@@ -1,75 +1,32 @@
-// interpret/pipeline.mjs — the multi-strategy interpretation pipeline (ROADMAP
-// item 8): run the request through ALL the classes of thing it could be, parse it
-// with each class's own strategy, then merge same-class results and surround
+// interpret/pipeline.mjs — the multi-strategy interpretation pipeline: run
+// the request through every strategy, merge same-class results, and surround
 // distinct-class results with "if you mean X then …" (interpret/merge.mjs).
 //
-// A STRATEGY is a plain object:
-//   { id, class, run(text, ctx) -> {strategyId, class, candidates:[{parsed,
-//     confidence?, note?, via?}]} | null }
-// `via` marks an APPROXIMATE reading ("fuzzy"/"lemma"/"spell"): the merge
-// discards approximate candidates whenever anything parsed exactly (the tier
-// discipline — exact curated match always wins — held across strategies).
-// `run` may be sync or async (Promise-returning); a strategy that THROWS or
-// rejects is dropped for that request — one broken strategy never takes the
-// pipeline down. Strategies are registered in the STRATEGIES array below in
-// PRECEDENCE order (earlier wins same-class dedupe ties and confidence ties) —
-// a new strategy (e.g. the Phase-2 ACE grammar, interpret/strategies/ace.mjs)
-// joins by pushing an entry here, not by editing the pipeline.
-//
-// NORMALIZATION PRE-PASS (ROADMAP item 10): interpret() normalizes the input
-// once (normalizeInput below — the same §3.5 pipeline + rhetorical frames
-// ask.mjs always ran) and hands every strategy the normalized text; the raw
-// text rides along in ctx.raw, and the returned record says whether
-// normalization changed the input (`normalizationChanged`), so a repaired
-// spelling/contraction is on the record, never silent.
+// A STRATEGY is { id, class, run(text, ctx) -> {strategyId, class,
+// candidates:[{parsed, confidence?, note?, via?}]} | null }. `via` marks an
+// APPROXIMATE reading ("fuzzy"/"lemma"/"spell"), discarded whenever anything
+// parsed exactly. `run` may be sync or async; a throwing/rejecting strategy
+// is dropped rather than taking the pipeline down. Registered in STRATEGIES
+// below, in precedence order.
 
 import { normalizeQuery, applyNegationFrames, applyPhrasingFrames } from "./normalize.mjs";
 import { grammarStrategy } from "./strategies/grammar.mjs";
 import { keywordSpotStrategy } from "./strategies/keywords.mjs";
 import { noiseStripStrategy } from "./strategies/noise-strip.mjs";
-// Optional Node-flavored ACE strategy — same viewer-bundle boundary as the
-// ask-nlp adapter below: the ACE grammar reaches grammar/ace.mjs -> lexicon.mjs,
-// which reads its committed JSON via Node fs, so an inlining viewer bundle strips
-// this import; the `typeof` guard where STRATEGIES is built then degrades to an
-// ace-less registry instead of throwing over an undeclared identifier. (ACE is
-// async-only anyway, so the sync parseQuery path the viewer uses never ran it.)
+// The next three are Node-only (fs/path-reading tooling); an inlining viewer
+// bundle strips them, and the `typeof` guards below degrade to a leaner
+// registry instead of throwing on an undeclared identifier.
 import { aceStrategy } from "./strategies/ace.mjs";
-// Optional Node-only construction-grammar bank (PLAN_ADVANCED_GRAMMAR.md track
-// (d)) — same viewer-bundle boundary as ACE and the wink adapter: the loader
-// reads its committed TOML data via Node fs/path (interpret/strategies/
-// constructions.mjs), so an inlining viewer bundle strips this import too; the
-// same `typeof` guard below degrades to a constructions-less registry instead
-// of throwing over an undeclared identifier (test/ask-nlp.test.mjs's "viewer
-// bundle without wink" test proves the boundary — its bundled file list never
-// includes this strategy file, matching ace.mjs's own exclusion there).
 import { constructionsStrategy } from "./strategies/constructions.mjs";
 import { mergeStrategyResults } from "./merge.mjs";
-// Optional Node-only wink adapter — same viewer-bundle boundary as ask.mjs: an
-// inlining bundle strips this import and the `typeof` read below degrades to
-// adapter-less parsing instead of throwing over an undeclared identifier.
 import { nlpAdapter } from "../ask-nlp.mjs";
 
-/** The registered strategies, in precedence order. grammar + keyword-spot are
- *  the two legacy parsers (one shared class, "graph-query" — their merge is
- *  byte-identical to the original two-way agree/disagree behavior); noise-strip
- *  is the item-10 tolerant fallback (its own class; it only fires when the
- *  anchored grammar missed the text as-given, so it can never displace an
- *  existing template parse). interpret/strategies/ace.mjs (Phase 2 / Stage 2) is
- *  the ACE-OWL controlled-fragment grammar, registered here as an ADDITIVE, own-
- *  class ("ace-fact") strategy. It is ASYNC on purpose: runStrategiesSync (the
- *  parseQuery / CHATBENCH-facing path) SKIPS Promise-returning strategies, so ACE
- *  adds declarative-fragment reach to interpret() while leaving the sync spine
- *  byte-stable (see strategies/ace.mjs for the full rationale). The `typeof` guard
- *  mirrors the nlpAdapter degradation: a stripped ACE import (viewer bundle) leaves
- *  the identifier undeclared, so the registry is ace-less there instead of a crash.
- *  interpret/strategies/constructions.mjs (PLAN_ADVANCED_GRAMMAR.md track (d)) is
- *  the construction-grammar template bank — data-driven (data/templates/
- *  constructions/*.toml), registered as its own additive, own-class
- *  ("construction") strategy at grammar-level confidence (0.9) so it outranks a
- *  same-text keyword-spot guess outright instead of colliding with it (see that
- *  file's header for why: keyword-spot mis-parses the genitive/compound surface
- *  forms this bank exists to fix). Sync (unlike ACE), so it participates on the
- *  parseQuery path too, not just interpret(). */
+/** Registered strategies, in precedence order: grammar + keyword-spot (shared
+ *  "graph-query" class), noise-strip (fires only when the anchored grammar
+ *  misses), then the optional ACE and construction-grammar strategies, each
+ *  in its own class so it surfaces as an alternate rather than colliding with
+ *  a graph-query guess. ACE is async-only, so it participates via interpret()
+ *  only, not the sync parseQuery path. */
 // eslint-disable-next-line no-undef
 const OPTIONAL_STRATEGIES = [
   ...(typeof aceStrategy !== "undefined" ? [aceStrategy] : []),
@@ -78,9 +35,8 @@ const OPTIONAL_STRATEGIES = [
 ];
 export const STRATEGIES = [grammarStrategy, keywordSpotStrategy, noiseStripStrategy, ...OPTIONAL_STRATEGIES];
 
-/** The documented normalization pre-pass: whitespace-collapse + the §3.5
- *  normalization pipeline + the closed rhetorical-frame rewrites, applied ONCE
- *  before any strategy runs. Returns {raw, text, changed}. */
+/** Whitespace-collapse + normalization pipeline + rhetorical-frame rewrites,
+ *  applied once before any strategy runs. Returns {raw, text, changed}. */
 export function normalizeInput(input) {
   const raw = String(input || "").trim().replace(/\s+/g, " ");
   const text = raw ? applyPhrasingFrames(applyNegationFrames(normalizeQuery(raw))) : "";
@@ -91,10 +47,8 @@ function defaultNlp() {
   return typeof nlpAdapter === "function" ? nlpAdapter() : null;
 }
 
-/** Synchronous strategy run — the path ask.mjs's parseQuery routes through (its
- *  callers are synchronous). Skips a strategy that returns a Promise (an async
- *  strategy can only participate via interpret()); a throwing strategy is
- *  dropped, never a crash. Returns the strategy results in precedence order. */
+/** Synchronous strategy run (ask.mjs's parseQuery path). Skips a Promise-
+ *  returning strategy and drops a throwing one; returns results in precedence order. */
 export function runStrategiesSync(text, ctx = {}, strategies = STRATEGIES) {
   const results = [];
   for (const s of strategies) {
@@ -117,10 +71,8 @@ export function runStrategiesSync(text, ctx = {}, strategies = STRATEGIES) {
  *                                  //   {ambiguousParse, candidates} tie), or null
  *      alternates }                // distinct-class runners-up for the
  *                                  //   "if you mean X then …" surround
- *  `ctx.strategies` overrides the registry (tests, embedders); `ctx.nlp`
- *  overrides the lemma/POS adapter exactly as ask()'s own option does. Pure
- *  given (text, strategies, adapter) — no graph access here: resolving terms
- *  against a graph stays ask.mjs's job downstream. */
+ *  `ctx.strategies`/`ctx.nlp` override the registry/lemma adapter. No graph
+ *  access here — resolving terms against a graph is ask.mjs's job. */
 export async function interpret(text, ctx = {}) {
   const strategies = ctx.strategies || STRATEGIES;
   const { raw, text: normalized, changed } = normalizeInput(text);

package/src/interpret/strategies/ace.mjs

@@ -1,34 +1,11 @@
-// interpret/strategies/ace.mjs — the ACE-OWL controlled-fragment grammar wired
-// into the interpretation pipeline as an ADDITIVE strategy (Stage 2, "ACE reach").
-//
-// The ACE engine (src/grammar/ace.mjs) has existed since Phase 2, but its pipeline
-// ADAPTER was the "real and empty" seam the pipeline header names (interpret/
-// pipeline.mjs). This file fills it. The contract is strictly ADD-ONLY:
-//
-//   · Its own class, "ace-fact" — DISJOINT from the graph-query strategies, so a
-//     clean ACE parse is a distinct-class ALTERNATE ("if you mean X then …"), never
-//     a same-class competitor that could displace a graph-query winner.
-//   · It emits a candidate ONLY on a CLEAN parse (parseAce returns triples). A
-//     structural-fit-with-residue (empty triples) or a total miss returns null, so
-//     a query sentence that merely LOOKS relation-shaped ("which modules import X",
-//     whose ACE residue is the "which") contributes nothing — fitting the grammar
-//     is a strong signal; missing it is a FEATURE and the tolerant strategies win.
-//
-// WHY ASYNC — the byte-stability guarantee. ask.mjs's parseQuery (the CHATBENCH
-// chat-facing path) runs strategies through runStrategiesSync, which — by the
-// pipeline's documented contract — SKIPS any Promise-returning strategy ("an async
-// strategy can only participate via interpret()"). Registering ACE async therefore
-// makes the sync parseQuery path PROVABLY untouched (CHATBENCH neutral, byte-for-
-// byte) while interpret() — the async pipeline — gains the declarative-fragment
-// reach. The work parseAce does is synchronous; the async wrapper is deliberate,
-// the mechanical seam that keeps the chat spine frozen. (grammar/ace.mjs itself is
-// imported UNCHANGED — no chat-facing edit.)
+// interpret/strategies/ace.mjs — the ACE-OWL controlled-fragment grammar
+// (src/grammar/ace.mjs) wired into the pipeline as an additive strategy: its
+// own class ("ace-fact"), so a clean parse surfaces as an alternate, never
+// displacing a graph-query winner.
 
 import { parseAce } from "../../grammar/ace.mjs";
 
-/** Adapter: a clean ACE parse -> one candidate in its own class; anything else
- *  (residue-only structural fit, or a hard miss) -> null. `via:"exact"` — a
- *  controlled-grammar fit is exact evidence, never an approximate rewrite. */
+/** A clean ACE parse -> one candidate; a residue-only fit or a miss -> null. */
 export function runAce(text) {
   let parsed = null;
   try { parsed = parseAce(text); } catch { return null; }
@@ -36,9 +13,8 @@ export function runAce(text) {
   return { strategyId: "ace", class: "ace-fact", candidates: [{ parsed, confidence: 0.85, via: "exact", note: `ACE ${parsed.pattern}` }] };
 }
 
-/** Pipeline registration (interpret/pipeline.mjs). ASYNC on purpose (see file
- *  header): it participates in interpret() but is SKIPPED by runStrategiesSync,
- *  so parseQuery — and the CHATBENCH spine it feeds — is byte-stable. */
+/** Registered ASYNC so runStrategiesSync (the sync parseQuery path) skips it,
+ *  keeping that path byte-stable. */
 export const aceStrategy = {
   id: "ace",
   class: "ace-fact",

package/src/interpret/strategies/constructions.mjs

@@ -1,30 +1,12 @@
-// interpret/strategies/constructions.mjs — strategy N+1: construction-grammar
-// template banks (PLAN_ADVANCED_GRAMMAR.md track (d)). Per-construction closed
-// template families loaded as DATA from data/templates/constructions/*.toml
-// (pattern -> AST skeleton, slot types validated against the closed RELATIONS/
-// ENTITY_TO_TYPE vocabulary ask-vocab.mjs already owns), registered here as its
-// OWN additive class ("construction") — the same "own-class strategy" pattern
-// interpret/strategies/ace.mjs and noise-strip.mjs already use, so a construction
-// match outranks a same-text keyword-spot GUESS outright (interpret/merge.mjs
-// picks the highest-confidence CLASS; within-class disagreement is the honest
-// {ambiguousParse} tie, which this strategy deliberately avoids triggering
-// against keyword-spot by living in its own class) rather than colliding with it.
+// interpret/strategies/constructions.mjs — construction-grammar template
+// banks, loaded as DATA from data/templates/constructions/*.toml (pattern ->
+// AST skeleton, slot types validated against RELATIONS/ENTITY_TO_TYPE),
+// registered as its own additive class ("construction") so a match outranks
+// a same-text keyword-spot guess rather than colliding with it.
 //
-// The point (mirrors grammar.mjs's own file-header precedent, "same shape, new
-// grammatical coverage, not a new mechanism"): grammar GROWTH as committed data,
-// not more normalize.mjs/grammar.mjs code — data/templates/grammar-rules.toml
-// and data/templates/responses.jsonl already work this way. Continues
-// grammar.mjs's T1-T10 numbering (T11+, see the TOML file's own [[construction]]
-// `id` fields) without renumbering anything grammar.mjs already owns.
-//
-// Loader discipline (mirrors src/finish.mjs's loadGrammarRules/grammarRules
-// pattern exactly): synchronous (the pipeline is sync-capable), cached once per
-// process, and DEFENSIVE — a missing directory, unparseable TOML, or an entry
-// that fails validation (an unrecognized `kind`/`entityType`, a malformed
-// pattern) is silently DROPPED, never thrown and never guessed into the nearest
-// match. "One broken strategy/entry never takes the pipeline down"
-// (interpret/pipeline.mjs's own file-header discipline) extends here to one
-// broken DATA ROW never taking the strategy down.
+// Loader is synchronous, cached once per process, and defensive: a missing
+// directory, unparseable TOML, or invalid entry is silently dropped, never
+// thrown.
 
 import { readFileSync, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -72,8 +54,7 @@ export function readConstructionFiles(dir = CONSTRUCTIONS_DIR) {
 }
 
 /** Validate + index the raw [[relation]] rows into noun -> {kind, entityType}.
- *  Closed-vocabulary validation (the whole point of track (d)'s "slot types
- *  validated against ENTITY_TO_TYPE/VERB_TO_KIND" deliverable): `kind` MUST be
+ *  Closed-vocabulary validation: `kind` MUST be
  *  one of RELATIONS' own keys and `entityType` (when present) MUST be one of
  *  ENTITY_TO_TYPE's canonical class names — an entry failing either check is
  *  dropped, never coerced to the nearest-looking valid value. First occurrence
@@ -92,13 +73,8 @@ export function buildAgentNounTable(relations) {
   return table;
 }
 
-/** Compile one pattern string ("<AGENT> of <TERM>") against the closed agent-
- *  noun alternation into {re, agentIndex, termIndex}, or null when the pattern
- *  doesn't carry exactly one <AGENT> and one <TERM> token (a malformed pattern
- *  — dropped, not guessed at). Literal text is escaped and whitespace-
- *  normalized (\s+), matching every other anchored-template regex in this
- *  codebase (grammar.mjs's own TEMPLATES). Case-insensitive; tolerates one
- *  optional trailing "?", same as grammar.mjs's own templates. */
+/** Compile one pattern string ("<AGENT> of <TERM>") into {re, agentIndex,
+ *  termIndex}, or null when it doesn't carry exactly one of each token. */
 function compilePattern(pattern, agentNouns) {
   if (typeof pattern !== "string" || !pattern.trim() || !agentNouns.length) return null;
   const agentAlt = agentNouns.slice().sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
@@ -189,12 +165,9 @@ export function parseConstruction(text, bank = constructionBank()) {
   return null;
 }
 
-/** Pipeline registration (interpret/pipeline.mjs): construction-grammar
- *  templates as their OWN class ("construction"), confidence 0.9 — the same
- *  evidentiary weight as grammar.mjs's anchored T1-T10 (an anchored, closed
- *  pattern match), so it outright outranks a same-text "graph-query"-class
- *  keyword-spot guess (0.7) instead of triggering a same-class {ambiguousParse}
- *  tie against it (see this file's header). */
+/** Pipeline registration: own class ("construction"), confidence 0.9 — same
+ *  weight as grammar.mjs's anchored templates, so it outranks a same-text
+ *  keyword-spot guess (0.7) rather than tying against it. */
 export const constructionsStrategy = {
   id: "constructions",
   class: "construction",

package/src/interpret/strategies/grammar.mjs

@@ -18,21 +18,9 @@ const MODIFIER_ALT = Object.keys(MODIFIER_TO_KIND).sort((a, b) => b.length - a.l
 const META_ALT = META_MEANING_VERBS.slice().sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
 
 const TEMPLATES = [
-  // T1 ASK: "does X import Y" / "is X a subclass of Y" -> Yes/No. Tried FIRST: it starts with
-  // does/is/do/did, which the reverse/forward templates below never match (those start with
-  // which/what), so precedence between T1 and the rest is structural, not a tie-break guess.
-  // "did" joins does/do for the past-tense commit forms ("did commit <sha> touch X").
-  // REVERSE VERB SWAP (Seonix Batch 2 Fix 2): this template fixes subject/object by regex
-  // capture POSITION, not by the verb's semantic direction — fine for every forward verb
-  // ("subclass of", "imports", …), but "is X a superclass of Y" MEANS the reverse of "is X
-  // a subclass of Y" (Y inherits from X, not X from Y). INHERITS_REVERSE_VERBS (ask-vocab.mjs)
-  // is the closed set of such reverse phrasings; when the matched verb is one of them,
-  // subject/object are swapped here, once, at parse time — so downstream evaluation (ask.mjs)
-  // sees "is Y a subclass of X" and needs zero changes of its own. (In practice this exact
-  // regex only ever matches a does/do/did lead, so "is …" phrasings actually reach the "ask"
-  // shape via keywords.mjs's decomposition strategy instead — that strategy applies the same
-  // swap for the same reason; this branch is kept for any does/do/did-led phrasing that names
-  // a reverse verb, and for structural symmetry with that sibling strategy.)
+  // T1 ASK: "does X import Y" -> Yes/No. REVERSE VERB SWAP: a semantically-reverse
+  // verb ("superclass of") means the opposite of its forward counterpart, so
+  // INHERITS_REVERSE_VERBS (ask-vocab.mjs) swaps subject/object here at parse time.
   {
     name: "ask",
     re: new RegExp(`^(?:does|do|did)\\s+(.+?)\\s+(${VERB_ALT})\\s+(.+?)\\??$`, "i"),
@@ -45,7 +33,7 @@ const TEMPLATES = [
       return { shape: "ask", entityType: null, modifier: "direct", kind, subject, object };
     },
   },
-  // T2 reverse: "which <entity> [<modifier>] <verb> <object>" — the operator's own example shape.
+  // T2 reverse: "which <entity> [<modifier>] <verb> <object>".
   {
     name: "reverse",
     re: new RegExp(`^which\\s+(${ENTITY_ALT})\\s+(?:(${MODIFIER_ALT})\\s+)?(${VERB_ALT})\\s+(.+?)\\??$`, "i"),
@@ -67,51 +55,24 @@ const TEMPLATES = [
       kind: VERB_TO_KIND[m[2].toLowerCase()], object: m[1].trim(),
     }),
   },
-  // T4 meta: "what does <term> mean" — a question about the GRAPH'S OWN VOCABULARY
-  // (a SchemaClass/SchemaPredicate label, e.g. "cochange", or a raw prop token, e.g.
-  // "mgx:callsSymbol"), not a graph traversal over code edges. Tried after T3: T3 also
-  // starts "what does/do", but T3 only fires when the tail is a relation VERB_ALT
-  // phrase ("import"/"calls"/…), which "mean"/"means"/etc never are (disjoint tables —
-  // ask-vocab.mjs's file comment explains why they're kept separate), so the two never
-  // actually compete for the same input.
+  // T4 meta: "what does <term> mean" — a question about the graph's own vocabulary,
+  // not a graph traversal. VERB_ALT and META_ALT are disjoint tables, so this never
+  // competes with T3 for the same input.
   {
     name: "meta-mean",
     re: new RegExp(`^what\\s+(?:does|do|is|are)\\s+(.+?)\\s+(?:${META_ALT})\\??$`, "i"),
     build: (m) => ({ shape: "meta", entityType: null, modifier: "direct", kind: "meta", object: m[1].trim() }),
   },
-  // T5 meta: "what is a/an <term>" — the OTHER worked phrasing ("what is a Commit").
-  // Seonix Batch 2 Fix 1: the indefinite article is now OPTIONAL, but the BARE
-  // (no-article) form is restricted to the CLOSED vocabulary ENTITY_TO_TYPE already
-  // imported above (function/method/class/module/attribute/variable/change/commit,
-  // singular and plural) — build() returns null (same "this template didn't actually
-  // match, keep scanning" contract T8/"when" below already relies on — see
-  // parseAnchored's own docblock) when the bare form's object isn't one of those
-  // closed terms, so the scan falls through exactly as if this template had not
-  // matched at all. This keeps "what is a doohickey"/"widget"/"gizmo" (still routed
-  // here via the WITH-article, fully unrestricted `(.+?)` path — pinned to resolve as
-  // an honest meta miss downstream, ask-combo.test.mjs/chat-readback.test.mjs) working
-  // unmodified, while ALSO keeping the two pinned bare-form honest misses intact:
-  // "what is the meaning of this codebase" (ask.test.mjs/ask-dual-strategy.test.mjs)
-  // and "what is exposed" (ask.test.mjs:840) both have bare objects absent from
-  // ENTITY_TO_TYPE, so build() still rejects them and they still fall through to null.
-  // Fix 3: stripTrailingScopeFiller (ask-vocab.mjs) trims a curated trailing clause
-  // ("what is a Module in this graph" -> "Module") off the object before it's
-  // returned, so a scoping tail never corrupts the lookup term either the bare-form
-  // check above or downstream resolution/rendering perform. HANDOVER.md 2026-07-10
-  // item 8: stripTrailingDiscourseTag trims a bare trailing "then"/"though" the
-  // same way ("what is a component then" -> "component") — applied first, since a
-  // discourse tag sits outermost when both happen to stack.
+  // T5 meta: "what is a/an <term>" — the bare (no-article) form is restricted to
+  // the closed ENTITY_TO_TYPE vocabulary (build() -> null otherwise, falling
+  // through); the WITH-article form is unrestricted.
   {
     name: "meta-whatis",
     re: new RegExp(`^what\\s+(?:is|are)\\s+(?:(an?)\\s+)?(.+?)\\??$`, "i"),
     build: (m) => {
       const object = stripTrailingDiscourseTag(m[2].trim());
       if (!m[1] && !ENTITY_TO_TYPE[object.toLowerCase()]) return null; // bare form: closed-set only
-      // "what is a kind of X" / "what is a subclass of X" (ARTICLE_RELATION_CONTINUATIONS,
-      // ask-vocab.mjs): the captured object is itself the tail of a registered inherits
-      // verb's own "is a .../are a ..." phrasing, not a term to define — reject so this
-      // template yields no candidate at all and only keyword-spot's (unambiguous) reverse-
-      // inherits reading survives, instead of a spurious meta/inherits {ambiguousParse} tie.
+      // "what is a kind/subclass of X" is an inherits phrasing, not a term to define.
       const objLower = object.toLowerCase();
       if (m[1] && ARTICLE_RELATION_CONTINUATIONS.some(
         (c) => objLower === c || objLower.startsWith(`${c} `),
@@ -119,8 +80,8 @@ const TEMPLATES = [
       return { shape: "meta", entityType: null, modifier: "direct", kind: "meta", object: stripTrailingScopeFiller(object) };
     },
   },
-  // T6 mention: "where is <term> mentioned/referenced" — the prose/mentions surface
-  // (2026-07-02 query families). Tried BEFORE T7: T7's trailing marker is optional,
+  // T6 mention: "where is <term> mentioned/referenced" — the prose/mentions surface.
+  // Tried BEFORE T7: T7's trailing marker is optional,
   // so without this ordering it would swallow the mention question and lose the
   // marker that distinguishes "locate the definition" from "list the prose mentions".
   {
@@ -148,19 +109,19 @@ const TEMPLATES = [
       ? { shape: "when", entityType: null, modifier: "direct", kind: "touches", object: m[1].trim() }
       : null),
   },
-  // T9 commit-history NP (PLAN_CHAT_FEEL item 6 remainder): "the commit history of
-  // X" / "commit history for X" — an NP form of T8's SAME "when did X change"
-  // intent; reuses shape="when" verbatim so evaluation/rendering are byte-
-  // identical, only the recognizer surface differs.
+  // T9 commit-history NP: "the commit history of X" / "commit history for X" —
+  // an NP form of T8's SAME "when did X change" intent; reuses shape="when"
+  // verbatim so evaluation/rendering are byte-identical, only the recognizer
+  // surface differs.
   {
     name: "commit-history",
     re: /^(?:the\s+)?commit\s+history\s+(?:of|for)\s+(.+?)\??$/i,
     build: (m) => ({ shape: "when", entityType: null, modifier: "direct", kind: "touches", object: m[1].trim() }),
   },
-  // T10 cochange-partners NP (PLAN_CHAT_FEEL item 6 remainder): "cochange partners
-  // of X" — an NP form of the existing "which modules cochange with X" verb-phrase
-  // shape (ask-vocab.mjs's cochange verb table); reuses shape="reverse"/
-  // kind="cochange" so evaluation is byte-identical.
+  // T10 cochange-partners NP: "cochange partners of X" — an NP form of the
+  // existing "which modules cochange with X" verb-phrase shape (ask-vocab.mjs's
+  // cochange verb table); reuses shape="reverse"/kind="cochange" so evaluation
+  // is byte-identical.
   {
     name: "cochange-partners",
     re: /^co-?change\s+partners\s+(?:of|for|with)\s+(.+?)\??$/i,