@polycode-projects/the-mechanical-code-talker 1.5.4 → 1.8.3

package/src/grammar/lexicon.mjs

@@ -154,26 +154,76 @@ export function loadLexicon(extra, ns = DEFAULT_NS) {
   return lex;
 }
 
-/** Noun lookup with plural folding; returns the entry ({lemma, property?}) or null. */
-export function lookupNoun(lexicon, word) {
+/** Noun lookup with plural folding; returns the entry ({lemma, property?}) or null.
+ *  `opts.singularOnly` (set by ace.mjs's resolveNP for an "a"/"an" determiner —
+ *  the only ACE determiners that are grammatically singular-ONLY) prunes the
+ *  irregular-plural fold when the SAME surface word is ALSO declared as its own
+ *  standalone noun (die/dice, person/people, tooth/teeth): a singular-only
+ *  determiner is incompatible with the plural-fold reading but fully compatible
+ *  with the standalone-singular reading, so that's the one grammar agreement
+ *  allows. A general rule keyed on determiner agreement, not a per-word carve-out
+ *  — see lookupNounCandidates below for the multi-candidate form this wraps. */
+export function lookupNoun(lexicon, word, opts = {}) {
+  return lookupNounCandidates(lexicon, word, opts)[0] ?? null;
+}
+
+/** Every lexicon entry `word` could plausibly resolve to, ranked with the SAME
+ *  top choice lookupNoun would return (opts.singularOnly applies identically)
+ *  but without discarding a genuine alternate — e.g. the die/dice collision
+ *  returns BOTH the `dice` and `die` entries (order depends on
+ *  opts.singularOnly), a regular -s fold with both forms independently
+ *  declared returns both. Additive: existing callers that only want the single
+ *  best answer keep using lookupNoun untouched. */
+export function lookupNounCandidates(lexicon, word, opts = {}) {
   const w = String(word ?? "").toLowerCase();
+  const standalone = lexicon.nouns.get(w);
   const irregular = lexicon.nounPlurals.get(w);
-  if (irregular) return lexicon.nouns.get(irregular) ?? null;
+  const out = [];
+  const seen = new Set();
+  const push = (entry) => {
+    if (entry && !seen.has(entry.lemma)) { seen.add(entry.lemma); out.push(entry); }
+  };
+  if (irregular) {
+    const irregularEntry = lexicon.nouns.get(irregular) ?? null;
+    if (opts.singularOnly && standalone) {
+      // grammatical-agreement pruning: "a"/"an" rules out the plural-fold
+      // reading, so the standalone singular entry is ranked FIRST here.
+      push(standalone);
+      push(irregularEntry);
+    } else {
+      push(irregularEntry);
+      push(standalone);
+    }
+    return out;
+  }
   for (const cand of foldCandidates(w)) {
-    const hit = lexicon.nouns.get(cand);
-    if (hit) return hit;
+    push(lexicon.nouns.get(cand));
   }
-  return null;
+  return out;
 }
 
 /** Verb lookup with 3sg folding; returns the entry ({lemma, prep?, predicate?}) or null. */
 export function lookupVerb(lexicon, word) {
+  return lookupVerbCandidates(lexicon, word)[0] ?? null;
+}
+
+/** Every verb entry `word` could plausibly resolve to via foldCandidates,
+ *  most-specific-fold-first (same order lookupVerb's single answer already
+ *  used) — additive sibling of lookupNounCandidates, for a caller that wants
+ *  to know about a genuine fold collision instead of only the first hit. In
+ *  practice a verb fold rarely collides (unlike nouns' irregular-plural
+ *  table), but the shape is symmetric with lookupNounCandidates on purpose —
+ *  ace.mjs's multi-candidate relation search (parseRelationHits) reads
+ *  whichever of the two a token's part of speech calls for. */
+export function lookupVerbCandidates(lexicon, word) {
   const w = String(word ?? "").toLowerCase();
+  const out = [];
+  const seen = new Set();
   for (const cand of foldCandidates(w)) {
     const hit = lexicon.verbs.get(cand);
-    if (hit) return hit;
+    if (hit && !seen.has(hit.lemma)) { seen.add(hit.lemma); out.push(hit); }
   }
-  return null;
+  return out;
 }
 
 /** Adjective lookup (exact lemma); returns {lemma, type, property?, value?} or null. */

package/src/graph-merge.mjs

@@ -0,0 +1,114 @@
+// graph-merge.mjs — multi-graph payload merging (the CLI/config unification
+// batch's multi-graph support). Used ONLY by source.mjs's fetchEntities when a
+// config carries more than one graph file (`config.graphFiles.length > 1`);
+// the single-graph path never calls this — that byte-identical guarantee
+// lives in source.mjs, not here.
+//
+// Individual ids are NOT collision-safe across repos — codegraph.mjs builds
+// ids as `mod:${relativePath}` (repo-relative), so two graphs describing
+// similarly-structured repos can collide. mergeEntityPayloads concatenates the
+// straightforward arrays (classes/vocabulary/objectProperties/individuals),
+// unions proseIndex (merging the id-array per word key), and — Option A, only
+// on an ACTUAL collision — prefixes the specific colliding ids (and every
+// in-payload reference to them: derived_from entries, mentions, edge subject/
+// object, proseIndex entries) with `<graphName>/`. Ids that never collide pass
+// through untouched, so the common (no-collision) case stays fully readable.
+
+/** Every individual id a payload declares, as a Set (cheap membership tests). */
+function idsOf(payload) {
+  const s = new Set();
+  for (const ind of Array.isArray(payload?.individuals) ? payload.individuals : []) {
+    if (ind && ind.id) s.add(ind.id);
+  }
+  return s;
+}
+
+/**
+ * Merge N single-graph entities payloads into one.
+ *
+ * @param {Array<{file?: string, payload: object, name?: string}>} entries
+ *   one entry per graph file already read+parsed; `name` is an explicit
+ *   tmct.toml `[[graphs]]` name, defaulting to the entry's array index
+ *   (stringified) when absent.
+ * @returns {object} a payload of the exact shape parseEntities/fetchEntities
+ *   already produce for a single graph: {generated_at, classes, vocabulary,
+ *   objectProperties, individuals, proseIndex, bootstrap?}.
+ */
+export function mergeEntityPayloads(entries) {
+  const list = (Array.isArray(entries) ? entries : []).map((e, i) => ({
+    file: e?.file,
+    payload: e?.payload || {},
+    name: e?.name != null && String(e.name).length ? String(e.name) : String(i),
+  }));
+
+  // Set-based collision detection, O(n): an id "collides" when it appears in
+  // more than one payload's own individuals list.
+  const idSets = list.map(({ payload }) => idsOf(payload));
+  const seenInCount = new Map();
+  for (const s of idSets) for (const id of s) seenInCount.set(id, (seenInCount.get(id) || 0) + 1);
+  const colliding = new Set([...seenInCount.entries()].filter(([, n]) => n > 1).map(([id]) => id));
+
+  const merged = {
+    generated_at: "",
+    classes: [],
+    vocabulary: [],
+    objectProperties: [],
+    individuals: [],
+    proseIndex: {},
+  };
+  let latestGeneratedAt = "";
+  let everyPayloadIsBootstrap = list.length > 0;
+
+  for (const { payload, name } of list) {
+    everyPayloadIsBootstrap = everyPayloadIsBootstrap && Boolean(payload.bootstrap);
+    if (typeof payload.generated_at === "string" && payload.generated_at > latestGeneratedAt) {
+      latestGeneratedAt = payload.generated_at;
+    }
+
+    const rewriteId = (id) => (colliding.has(id) ? `${name}/${id}` : id);
+
+    if (Array.isArray(payload.classes)) merged.classes.push(...payload.classes);
+    if (Array.isArray(payload.vocabulary)) merged.vocabulary.push(...payload.vocabulary);
+
+    for (const ind of Array.isArray(payload.individuals) ? payload.individuals : []) {
+      if (!ind) continue;
+      const out = { ...ind };
+      if (out.id) out.id = rewriteId(out.id);
+      if (Array.isArray(out.derived_from)) {
+        out.derived_from = out.derived_from.map((r) => rewriteId(r));
+      }
+      if (Array.isArray(out.mentions)) {
+        out.mentions = out.mentions.map((m) => (m && m.id ? { ...m, id: rewriteId(m.id) } : m));
+      }
+      merged.individuals.push(out);
+    }
+
+    for (const grp of Array.isArray(payload.objectProperties) ? payload.objectProperties : []) {
+      if (!grp) continue;
+      const out = { ...grp };
+      if (Array.isArray(out.examples)) {
+        out.examples = out.examples.map((e) => {
+          if (!e) return e;
+          const ne = { ...e };
+          if (ne.subject) ne.subject = rewriteId(ne.subject);
+          if (ne.object) ne.object = rewriteId(ne.object);
+          return ne;
+        });
+      }
+      merged.objectProperties.push(out);
+    }
+
+    const proseIndex = payload.proseIndex && typeof payload.proseIndex === "object" ? payload.proseIndex : {};
+    for (const [word, ids] of Object.entries(proseIndex)) {
+      const bucket = merged.proseIndex[word] || (merged.proseIndex[word] = []);
+      for (const id of Array.isArray(ids) ? ids : []) {
+        const rewritten = rewriteId(id);
+        if (!bucket.includes(rewritten)) bucket.push(rewritten);
+      }
+    }
+  }
+
+  merged.generated_at = latestGeneratedAt;
+  if (everyPayloadIsBootstrap) merged.bootstrap = true;
+  return merged;
+}

package/src/index.mjs

@@ -39,3 +39,17 @@ export { foldSessionLogs } from "./memory/fold.mjs";
 // (docs/adapter-contract.md): registerProvider() plugs a producer in;
 // fetchEntities() is the one read path.
 export { fetchEntities, registerProvider } from "./source.mjs";
+
+// `tmct init` onboarding (also reachable as the `./init` subpath export).
+// init.mjs and toml-config.mjs each export a same-named `CONFIG_FILE`
+// constant ("tmct.toml") — aliased here so both can ride the one `.` entry
+// point without colliding.
+export { initRepo, defaultConfig, renderTomlConfig, PERSONA_PRESETS, CONFIG_FILE as INIT_CONFIG_FILE } from "./init.mjs";
+
+// tmct.toml loading (also reachable as the `./toml-config` subpath export).
+export { CONFIG_FILE as TOML_CONFIG_FILE } from "./toml-config.mjs";
+
+// The "detailed answer" completions pipeline (also reachable as the
+// `./generateCompletion` and `./createCompletionsGraphAdapter` subpath exports).
+export { generateCompletion } from "./completions/complete.mjs";
+export { createCompletionsGraphAdapter } from "./completions/graph-adapter.mjs";

package/src/init.mjs

@@ -57,16 +57,34 @@ export function defaultConfig() {
 }
 
 /** `tmct init --with-persona <name>` presets (Part 7 of the extension-pack
- *  batch): a named bundle of `extensions`/`bias` overrides, written into
- *  tmct.toml alongside the plain defaults. `code` is TODAY'S IMPLICIT
- *  DEFAULT made explicit — an empty `extensions` override (seon + conceptnet
- *  are already the shipped builtin defaults; nothing to add) plus an
- *  EXPLICIT bias table naming them both at neutral weight, so a repo that
- *  chose the `code` persona has a self-documenting tmct.toml rather than
- *  relying on an unstated implicit default. Kept minimal on purpose — this
- *  batch's job is the persona SEAM, not a curated library of presets. */
+ *  batch; PLAN_SEED.md §2 flips which preset is the SHIPPED implicit
+ *  default): a named bundle of `extensions`/`bias` overrides, written into
+ *  tmct.toml alongside the plain defaults.
+ *
+ *  - `human` — the NEW implicit default (src/extensions.mjs's
+ *    BUILTIN_EXTENSIONS already ships `human` active and `seon`/`conceptnet`
+ *    inactive) made EXPLICIT: an empty `extensions` override (nothing to
+ *    add — the builtin defaults already are this persona) plus an explicit
+ *    `[bias] human = 1.0`, so a repo that asks for `--with-persona human`
+ *    has a self-documenting tmct.toml rather than relying on an unstated
+ *    implicit default — the exact same discipline `code` below already used
+ *    for the OLD default.
+ *  - `code` — TODAY'S OLD IMPLICIT DEFAULT, now something a repo must
+ *    request explicitly: re-activates `seon`+`conceptnet` (both now
+ *    shipped inactive) and sets their bias, for a caller (e.g. seonix's own
+ *    code-domain chat surface) that still wants the software-domain seed.
+ *  - `empty` — the advanced escape hatch (PLAN_SEED.md §7): deactivates the
+ *    one bundle now active by default (`human`), leaving a repo genuinely
+ *    empty of corpus facts for a consumer bringing its own ontology/lexicon/
+ *    corpus. Does NOT reduce npm package size (§7's own documented caveat —
+ *    `corpus/` ships unconditionally either way).
+ *
+ *  Kept minimal on purpose — this batch's job is the persona SEAM, not a
+ *  curated library of presets. */
 export const PERSONA_PRESETS = Object.freeze({
-  code: { extensions: {}, bias: { seon: 1.0, conceptnet: 1.0 } },
+  human: { extensions: {}, bias: { human: 1.0 } },
+  code: { extensions: { seon: { active: true }, conceptnet: { active: true } }, bias: { seon: 1.0, conceptnet: 1.0 } },
+  empty: { extensions: { human: { active: false } }, bias: {} },
 });
 
 /** Read this package's version (best-effort, for provenance). */
@@ -105,7 +123,14 @@ export function renderTomlConfig(config = defaultConfig()) {
 # Where the code-graph JSON artifact lives, relative to this file. The
 # TMCT_GRAPH_FILE environment variable overrides it at runtime.
 graph_file = ${JSON.stringify(c.graphFile)}
-
+${Array.isArray(c.graphFiles) && c.graphFiles.length ? `
+# graph_files — additional graph artifacts (multi-graph). Merged with
+# graph_file at read time (src/graph-merge.mjs); an id that collides
+# across graphs is auto-prefixed with its graph's name, everything else
+# passes through unchanged. Written by \`tmct init --graph\`/\`tmct import
+# --graph\`.
+graph_files = ${JSON.stringify(c.graphFiles)}
+` : ""}
 [corpus]
 # Corpus-tiering policy (ROADMAP Phase 4). The $0-offline default is inviolable;
 # higher tiers are ADDITIVE and never required to answer.
@@ -135,10 +160,11 @@ ${seed.limit != null ? `limit = ${Number(seed.limit)}` : "# limit = 500"}
   if (!Object.keys(extras).length) return base;
   return `${base}
 # Extension packs + bias (src/extensions.mjs) — written by \`tmct init --with-persona\`
-# or a manual edit. Recognized names (seon, conceptnet, tier2-aws, tier2-python,
-# tier2-java) override the shipped defaults; any other name declares a new
-# host-supplied bundle (needs its own "kind"). [bias] is a flat bundle-name ->
-# weight table consumed by src/memory/bias.mjs's ranking.
+# or a manual edit. Recognized names (human, seon, conceptnet, tier2-aws,
+# tier2-python, tier2-java, tier2-general) override the shipped defaults; any
+# other name declares a new host-supplied bundle (needs its own "kind").
+# [bias] is a flat bundle-name -> weight table consumed by
+# src/memory/bias.mjs's ranking.
 ${stringifyToml(extras)}`;
 }
 

package/src/interpret/normalize.mjs

@@ -13,7 +13,7 @@
 
 import {
   CONTRACTIONS, MISSPELLINGS, WRONG_WORDS, G_DROP, FILLER_WORDS,
-  NEGATION_FRAMES, COMMIT_CONTENT_FRAMES, VERB_TO_KIND,
+  NEGATION_FRAMES, COMMIT_CONTENT_FRAMES, VERB_TO_KIND, ENTITY_TO_TYPE,
 } from "../ask-vocab.mjs";
 
 export function escapeRegex(s) {
@@ -44,6 +44,55 @@ const correctionRe = (table) => new RegExp(
 const MISSPELLING_RE = correctionRe(MISSPELLINGS);
 const WRONG_WORD_RE = correctionRe(WRONG_WORDS);
 
+// ---- two deferred typo sub-cases (HANDOVER.md 2026-07-12, routed from
+// BENCHMARK_CONVERSATION_1.7.0.md's "Routed backlog": "cochange w/ wat",
+// "tests 4 it") that structurally CANNOT live in the MISSPELLINGS/WRONG_WORDS
+// tables above, for two independent reasons:
+//   - correctionRe() builds `\b(...)\b` from a table's keys. A key of "w/"
+//     can never satisfy the trailing `\b`: both "/" and the whitespace that
+//     follows it are non-word characters, so no word-boundary transition
+//     ever happens there — no table entry, however spelled, can match.
+//   - "with" and "for" are not canonical grammar-owned words (not in
+//     VERB_TO_KIND/ENTITY_TO_TYPE/MODIFIER_TO_KIND/TRIGGER_WORDS), and
+//     test/ask-vocab.test.mjs enforces that every correction TABLE value is
+//     one of those — by design, so a table entry couldn't rewrite INTO a
+//     non-grammar word either.
+// Same species as chat.mjs's VAGUE_TOUCH_TEL_RE/VAGUE_TOUCH_ABUT_RE (a
+// dedicated, narrowly-scoped regex pass instead of a table entry), wired
+// here rather than in chat.mjs because "w/" and leetspeak "4" are GENERAL
+// shorthand a developer can use in any question, not one lane's own anchor
+// word. normalize.mjs's normalizeQuery is the single point both ask.mjs's
+// parseQuery and interpret/pipeline.mjs's normalizeInput funnel every query
+// through, so wiring it here reaches every caller once. ----
+
+/** "w/" -> "with". Lookbehind/lookahead require whitespace (or start/end of
+ *  string) on BOTH sides, so a real path fragment ("src/w/foo.mjs" — the "/"
+ *  right before "w" is not whitespace) and the DIFFERENT shorthand "w/o"
+ *  ("without" — a non-whitespace "o" right after the slash) never match. */
+const W_SLASH_RE = /(?<=^|\s)w\/(?=\s|$)/gi;
+
+/** "4" meaning the word "for" — deliberately NOT a context-free standalone-
+ *  digit substitution. fuzzy.mjs's eligibleForCanon() and several independent
+ *  `/^[a-z]+$/` guards in ask.mjs protect digit tokens everywhere in this
+ *  codebase (shas, line numbers, counts — "top 4 results", "line 4", "commit
+ *  4a2b…") on purpose; a blind "4" -> "for" token rule would corrupt every
+ *  one of those. Narrowed to two closed, well-justified trigger shapes —
+ *  chosen SMALLER than the plausible "wait 4 X" / "used 4 X" leetspeak
+ *  because both of those anchors collide with genuine counts in ordinary
+ *  English ("wait 4 minutes", "used 4 times"), which this rule must never
+ *  touch:
+ *   - a GRATITUDE interjection immediately before "4" (the same closed word
+ *     list THANKS_PREAMBLE_RE above already trusts as pure gratitude, never
+ *     a count-report opener) — "thx 4 the help", "cheers 4 that".
+ *   - the "4 example"/"4 instance" idiom, guarded to fire ONLY when nothing
+ *     else follows on the same clause (end of string or punctuation next) —
+ *     "…, 4 example" / "4 example?" is the parenthetical "for example" idiom,
+ *     but "the 4 example modules" names a genuine COUNT of four example
+ *     modules, and the trailing-word lookahead refuses to rewrite that.
+ */
+const FOR_DIGIT_THANKS_RE = /\b(thx|thanks|thank\s+you|many\s+thanks|ty|cheers)\s+4\b/gi;
+const FOR_DIGIT_EXAMPLE_RE = /\b4\s+(example|instance)\b(?!\s*[a-z])/gi;
+
 /** "that class"/"this module"/"that function" (a context pronoun immediately
  *  followed by the SINGULAR kind noun it's already standing in for) -> the bare
  *  pronoun alone (0.9.15 Tier-1 single-touch playtest). "which class contains
@@ -64,6 +113,25 @@ const WRONG_WORD_RE = correctionRe(WRONG_WORDS);
  *  CONTEXT_PRONOUNS entry). */
 const KIND_NOUN_ANAPHORA_RE = /\b(this|that)\s+(class|module|function|method|attribute|variable|file|commit)\b/gi;
 
+/** Read-only PROBE (BENCHMARK_CONVERSATION_1.7.0.md routed backlog C2): does
+ *  `text` contain a KIND_NOUN_ANAPHORA_RE match, and if so, what ENTITY CLASS
+ *  does its kind noun name (ENTITY_TO_TYPE, ask-vocab.mjs — the same
+ *  "file"->"Module" convention every other lane in this grammar already
+ *  uses)? Returns that class, or null when no such anaphora is present.
+ *  Deliberately SEPARATE from normalizeQuery's own KIND_NOUN_ANAPHORA_RE
+ *  replace just above (which permanently collapses "this file" to bare
+ *  "this", discarding the kind-noun signal for good, by design — see that
+ *  replace's own docblock): this never mutates its input and has no effect
+ *  on normalizeQuery's behavior, signature, or any of its many call sites.
+ *  A caller that needs BOTH the collapsed pronoun AND the kind it stood for
+ *  (chat.mjs's runAsk, at its pronoun-reuse site) calls this side-channel on
+ *  the same raw text handed to normalizeQuery — order between the two calls
+ *  doesn't matter, since this one only ever reads. */
+export function kindNounAnaphoraHint(text) {
+  const m = new RegExp(KIND_NOUN_ANAPHORA_RE.source, "i").exec(String(text || ""));
+  return m ? (ENTITY_TO_TYPE[m[2].toLowerCase()] || null) : null;
+}
+
 // every relation verb phrase VERB_TO_KIND knows, as one alternation (longest-first
 // so a multi-word verb like "inherit from" wins over its own leading word "inherit"
 // appearing elsewhere) — feeds the DOES-X-VERB-ANYTHING-ELSE frame below, which needs
@@ -191,8 +259,19 @@ const ACK_PREAMBLE_RE = /^(?:(?:ok(?:ay)?|aight|cool|alright|sure|right|fine|gre
  *  §3: the vague-opener family a genuine first-time stranger types). Same
  *  delimiter-required discipline as GREETING/THANKS/ACK_PREAMBLE_RE above —
  *  a bare "just poking around" with no question stays small-talk (this file
- *  never claims a turn that has no remainder to hand back). */
-const BROWSING_PREAMBLE_RE = /^just\s+(?:poking\s+around|looking\s+around|browsing|exploring|checking\s+(?:this|it)\s+out)\s*[,.—–-]\s*(.+)$/i;
+ *  never claims a turn that has no remainder to hand back).
+ *  HANDOVER.md 2026-07-10 item 3: "first time trying this out"/"first time
+ *  using this"/"first time here" is the SAME self-orientation species — a
+ *  genuine stranger's opener, just phrased around their own inexperience
+ *  rather than what they're doing right now — found live as "hey, first
+ *  time trying this out - what is in here?" falling straight to the raw
+ *  grammar wall (GREETING_PREAMBLE_RE peels "hey,", but nothing recognized
+ *  the remainder as a preamble at all). Added as a sibling alternative in
+ *  the SAME regex/capture group, so it strips into the identical downstream
+ *  shape ("just poking around, X" and "first time trying this out, X" both
+ *  hand back the bare "X" for the ordinary pipeline to answer) rather than a
+ *  new frame with its own behavior. */
+const BROWSING_PREAMBLE_RE = /^(?:just\s+(?:poking\s+around|looking\s+around|browsing|exploring|checking\s+(?:this|it)\s+out)|first\s+time\s+(?:trying\s+this\s+out|using\s+this|here))\s*[,.—–-]\s*(.+)$/i;
 /** A repeated leading HEDGE ADVERB ("maybe", "possibly", "perhaps") ahead of a
  *  polite request verb — the sibling of ACK_PREAMBLE_RE for HEDGING rather than
  *  acknowledging (Tier 6 playtest §3's own stacked-politeness example: "could
@@ -528,6 +607,12 @@ export function normalizeQuery(text) {
   q = q.replace(CONTRACTION_RE, (m) => CONTRACTIONS[m.toLowerCase()]);
   q = q.replace(MISSPELLING_RE, (m) => MISSPELLINGS[m.toLowerCase()]);
   q = q.replace(WRONG_WORD_RE, (m) => WRONG_WORDS[m.toLowerCase()]);
+  // "w/" -> "with", leetspeak "4" -> "for" (narrow trigger shapes only) — see
+  // the two tables' own docblocks just above for why neither can live in the
+  // MISSPELLINGS/WRONG_WORDS tables above this function.
+  q = q.replace(W_SLASH_RE, "with");
+  q = q.replace(FOR_DIGIT_THANKS_RE, (_, w) => `${w} for`);
+  q = q.replace(FOR_DIGIT_EXAMPLE_RE, (_, w) => `for ${w}`);
   q = q.replace(KIND_NOUN_ANAPHORA_RE, (_, pron) => pron);
   q = q.replace(G_DROP, "$1ing");
   // closed preamble frames (greeting lead-in, modal wrapper, show/give-me

package/src/interpret/strategies/grammar.mjs

@@ -8,6 +8,7 @@ import {
   VERB_TO_KIND, ENTITY_TO_TYPE, MODIFIER_TO_KIND,
   META_MEANING_VERBS, WHERE_MARKERS, MENTION_MARKERS,
   INHERITS_REVERSE_VERBS, stripTrailingScopeFiller, stripTrailingDiscourseTag,
+  ARTICLE_RELATION_CONTINUATIONS,
 } from "../../ask-vocab.mjs";
 import { escapeRegex } from "../normalize.mjs";
 
@@ -106,6 +107,15 @@ const TEMPLATES = [
     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.
+      const objLower = object.toLowerCase();
+      if (m[1] && ARTICLE_RELATION_CONTINUATIONS.some(
+        (c) => objLower === c || objLower.startsWith(`${c} `),
+      )) return null;
       return { shape: "meta", entityType: null, modifier: "direct", kind: "meta", object: stripTrailingScopeFiller(object) };
     },
   },

package/src/interpret/strategies/keywords.mjs

@@ -277,6 +277,26 @@ export function parseKeywordSpot(text, nlp = null) {
     return { shape: "ask", entityType: null, modifier: "direct", kind, subject, object };
   }
   if (afterText) return { shape: "reverse", entityType, modifier, kind, object: afterText };
+  // "what is a kind of class" / "what inherits from function" (live-caught 2026-07-11
+  // follow-up to the ambiguousParse fix, commit 5c858bf): entityHit above is found
+  // ANYWHERE in the sentence and marked consumed before afterText is computed, so
+  // when the "kind of X"/"inherits X" idiom's object IS ITSELF one of the four
+  // code-graph entity-type nouns (class/function/method/module — ENTITY_TO_TYPE's
+  // own keys), the entity match swallows the ENTIRE post-verb span as a (wrong, in
+  // this shape) grain qualifier, leaving afterText empty and no candidate at all —
+  // the query silently fails to parse rather than answering or declining honestly.
+  // Scoped narrowly to kind==="inherits" (the one relation whose object is routinely
+  // a bare vocabulary noun with no further qualifier) and only when the ENTIRE
+  // post-verb span was consumed by the entity match (nothing else remains to be an
+  // object): re-read that span as the literal OBJECT text instead, entityType null
+  // (it names the thing being asked about here, not a grain filter on some other
+  // object). Every other kind/shape is unaffected — this never fires unless
+  // afterText is otherwise empty AND the sole cause is an entity-consumed span
+  // immediately after the verb.
+  if (kind === "inherits" && !beforeText && entityHit && entityHit.start === verbHit.end) {
+    const entityText = canonWords.slice(entityHit.start, entityHit.end).join(" ");
+    if (entityText) return { shape: "reverse", entityType: null, modifier, kind, object: entityText };
+  }
   // forward keeps the spotted entityType ("which modules did commit <sha> touch" is a
   // forward decomposition — subject before the verb — whose asked grain would otherwise
   // be lost); traverse() only consults it for the commit-as-subject grain selection,

package/src/interpret/strategies/noise-strip.mjs

@@ -73,11 +73,62 @@ const KEEP = new Set([
  *  carried here too so the strategy stands alone) + the cascade's noise list. */
 const CURATED_NOISE = new Set([...wordsOf(FILLER_WORDS), ...wordsOf(CASCADE_NOISE)]);
 
-/** Strip the strippable tokens (see the file doc). Returns {text, dropped}. */
+/** Words this pass keeps but flags as UNCERTAIN (PLAN_CONVERSATION.md Finding 2
+ *  — the "store"/"keep" gap): wink's `isStopWord` is a generic English
+ *  dictionary, not purpose-built for this codebase — it happens to flag
+ *  "keep"/"put"/"get" but not their close synonyms "store"/"hold"/"place"/
+ *  "save" sitting in the exact same no-relation-verb slot ("where would i
+ *  keep/store a router"), so a KEPT word surviving the pass above is not
+ *  necessarily real content. A curated synonym list was tried and rejected
+ *  (see the file doc / PLAN_CONVERSATION.md): "store"/"hold"/"save" are
+ *  exactly the words most likely to ALSO be a real identifier ("where does
+ *  the store live" must not lose its subject). The general, non-curated
+ *  signal that discriminates the two: wink's POS tagger, reading the WHOLE
+ *  ORIGINAL sentence for real grammatical context (an isolated 2-word
+ *  fragment like "store router" tags BOTH words NOUN — confirmed live; the
+ *  same "store" in "where would i store a router" tags VERB, and in "where
+ *  does the store live" tags NOUN — also confirmed live, so the isolated
+ *  object phrase alone can never carry this signal; it must be read here,
+ *  off the whole sentence, before the phrase is extracted).
+ *
+ *  A KEPT word wink tags VERB here is returned as `maybeNoise`, NOT stripped
+ *  outright — this function has no graph to check a resolution against
+ *  (interpret/pipeline.mjs's own documented boundary: "no graph access
+ *  here"). The caller below turns this into a second candidate reading;
+ *  ask.mjs's traverse() (where the graph lives) tries both and prunes the
+ *  one that misses/ties in favor of the one that resolves cleanly —
+ *  mirroring resolveObject's own grain-word retry (try a variant, keep it
+ *  only on an unambiguous hit) and grammar/ace.mjs's parseAceAmbiguous
+ *  ("keep only complete, valid parses"). Never guessed here; always pruned
+ *  where the evidence (the graph) actually is. */
+function maybeVerbNoiseWords(words, kept, nlp) {
+  if (!nlp || typeof nlp.posTags !== "function" || !kept.length) return [];
+  const keptSet = new Set(kept.map((w) => w.toLowerCase()));
+  let tags;
+  try {
+    tags = nlp.posTags(words);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (let i = 0; i < words.length; i += 1) {
+    const w = words[i];
+    const lc = w.toLowerCase();
+    if (!/^[a-z]+$/.test(w) || KEEP.has(lc) || !keptSet.has(lc)) continue;
+    if (tags[i] === "VERB") out.push(lc);
+  }
+  return out;
+}
+
+/** Strip the strippable tokens (see the file doc). Returns {text, dropped,
+ *  maybeNoise} — maybeNoise is the POS-flagged uncertain-word list above,
+ *  `[]` whenever no `nlp` adapter is available (same graceful-degradation
+ *  discipline as the rest of this file: never a curated guess, never a throw). */
 export function stripNoise(text, nlp = null) {
+  const words = splitWords(text);
   const kept = [];
   const dropped = [];
-  for (const w of splitWords(text)) {
+  for (const w of words) {
     const lc = w.toLowerCase();
     const strippable = /^[a-z]+$/.test(w) && !KEEP.has(lc)
       && (CURATED_NOISE.has(lc)
@@ -85,7 +136,8 @@ export function stripNoise(text, nlp = null) {
     if (strippable) dropped.push(w);
     else kept.push(w);
   }
-  return { text: kept.join(" "), dropped };
+  const maybeNoise = maybeVerbNoiseWords(words, kept, nlp);
+  return { text: kept.join(" "), dropped, maybeNoise };
 }
 
 /** Pipeline registration (interpret/pipeline.mjs). */
@@ -94,7 +146,7 @@ export const noiseStripStrategy = {
   class: "noise-stripped",
   run(text, ctx = {}) {
     if (parseAnchored(text)) return null; // the grammar owns the text as-given
-    const { text: stripped, dropped } = stripNoise(text, ctx.nlp || null);
+    const { text: stripped, dropped, maybeNoise } = stripNoise(text, ctx.nlp || null);
     if (!dropped.length || !stripped) return null;
     // tier 1: the anchored templates over the stripped text — the strictest
     // re-parse, tried first so a template shape is never displaced by a looser
@@ -105,6 +157,23 @@ export const noiseStripStrategy = {
     // (see the file doc for the discipline/cost argument).
     const parsed = parseAnchored(stripped) || parseKeywordSpot(stripped, ctx.nlp || null);
     if (!parsed) return null;
+    // Finding 2 extension (PLAN_CONVERSATION.md): a bare "where"/"mentions"
+    // question is the ONE shape with no explicit relation verb gating its
+    // object (every other decomposition in keywords.mjs requires a real
+    // VERB_TO_KIND match before it ever runs), so it's the only place an
+    // unlisted light verb ("store", "hold", …) can leak into the object
+    // phrase untouched. Scoped to exactly that shape — deliberately not a
+    // blanket change to stripNoise's shared criteria, per the file's own
+    // construction-scoping caveat. `altObject` rides along on the SAME
+    // single candidate (not a second strategy candidate — that would force
+    // mergeStrategyResults' pre-resolution ambiguousParse surface on every
+    // hit, before anyone has checked whether it's even real ambiguity);
+    // ask.mjs's traverse() is the one place both the alternate reading and
+    // the graph are available together to actually prune it.
+    if (maybeNoise.length && (parsed.shape === "where" || parsed.shape === "mentions") && parsed.object) {
+      const altObject = parsed.object.split(/\s+/).filter((w) => !maybeNoise.includes(w.toLowerCase())).join(" ").trim();
+      if (altObject && altObject !== parsed.object) parsed.altObject = altObject;
+    }
     return {
       strategyId: "noise-strip",
       class: "noise-stripped",