@polycode-projects/seonix 0.1.0 → 0.2.0

package/bin/cli.mjs

@@ -4,11 +4,24 @@
 //
 //   seonix                                              → stdio MCP server
 //   seonix cli index_repository '{"repo_path":"<abs>"}' → deterministic index
+//     (honours <repo>/.seonixignore — gitignore-subset patterns; pass
+//      `"ignores":false` in the JSON arg to index everything regardless)
 //   seonix cli digest '{"repo_path":"<abs>","modules":[…]}' → architecture map + per-module
 //                                                           context bundles to stdout (no-MCP arm)
+//   seonix cli digest '{"repo_path":"<abs>","query":"<free text>"}' → same, but auto-locates +
+//     score-gap-selects the modules (R1b, the shipped default) instead of requiring an explicit
+//     `modules` list — one call from a question to a digest. `modules` wins if both are given.
+//   seonix cli browser_link '{"query":"<nl-ish or grammar>","at":"<sha>","base":"<url>"}' → NL→query→URL:
+//     map a natural-language-ish request to the code-browser query grammar (deterministic, no model),
+//     SELF-TEST it against the local temporal graph (≥1 match, cursors resolve), print the URL;
+//     exit 1 on a link that would render empty. `"grammar":true` takes the query verbatim.
 //   seonix cli <toolName> '{…args}'                     → invoke ANY MCP tool via Bash (no MCP)
+//     (e.g. seonix cli seonix_ask '{"query":"<free text>"}' — mechanical, no-LLM NL question
+//      over the graph, PLAN_MECHANICAL_CHAT.md; no bespoke wiring needed, this fallback covers it)
 //   seonix hook-augment                                 → PreToolUse Grep/Glob augmenter (stdin→stdout)
-//   seonix viz [--focus <sym>] [--depth N] [--out f.html] → render a focused sub-graph to HTML
+//   seonix viz [--focus <sym>] [--depth N] [--out f.html] [--data-out f.json] [--repo-url <gitlab url> --ref main] [--site-nav] → render a focused sub-graph to HTML (one shared viewer; data embedded, or split out with --data-out)
+//   seonix viz --browser-out f.html [--browser-data-out f.json] [--scope product|<prefixes>] → also render the Chronograph code browser (temporal scrub + two-cursor diff + narration + ghost-branch merges + keyboard nav; PLAN_CODE_BROWSER.md)
+//   seonix viz --serve [--port N] [--focus <sym>]        → serve the same viewer against THIS repo's index (the local equivalent of the site's #viz; code browser at /code-browser.html, live-reannotating on HEAD change via /code-browser-version)
 //
 // The index step is offline and model-free (Python ast + git). It writes the
 // graph artifact to <repo_path>/.seonix/graph.json; the server (started with
@@ -20,7 +33,7 @@ import { dispatchTool, buildContextBundle } from "../src/server.mjs";
 import { indexRepository } from "../src/extract.mjs";
 import { loadConfig, DEFAULT_GRAPH_REL } from "../src/config.mjs";
 import * as source from "../src/source.mjs";
-import { parseEntities, renderSearch, rankModulesByProximity, searchModulesRanked } from "../src/codegraph.mjs";
+import { parseEntities, renderSearch, rankModulesByProximity, searchModulesRanked, selectRankedModules, DEFAULT_SCORE_GAP } from "../src/codegraph.mjs";
 
 /** Build a config pointed at a specific repo's artifact (for `cli` sub-commands that
  *  take a repo_path), or fall back to the cwd-derived default. */
@@ -44,6 +57,11 @@ const TIER_RANK = { NONE: 0, TINY: 1, MID: 2, LARGE: 3, FULL: 4 };
  *  renderer via buildContextBundle, so no render logic is duplicated). This stdout is injected
  *  into the no-MCP arm's prompt.
  *
+ *  Two ways to say which modules: an explicit `modules` array (unchanged), or a `query` string —
+ *  auto-locate + score-gap-select (R1b, the shipped default as of 2026-07-02) in one call, so a
+ *  real caller no longer has to run `seonix_locate` and hand-pick a module themselves. `modules`
+ *  wins if both are given. The header reports which modules were actually selected either way.
+ *
  *  B2: the FIRST (primary) module gets a full size-adaptive bundle; the remaining modules are
  *  RANKED by import/cochange proximity to the primary and only the top few get a TRIMMED
  *  (signatures + insertion region) bundle — so a 2-module task no longer pays for two full
@@ -51,12 +69,25 @@ const TIER_RANK = { NONE: 0, TINY: 1, MID: 2, LARGE: 3, FULL: 4 };
 async function runDigest(args) {
   const repoPath = args.repo_path;
   if (!repoPath) { process.stderr.write("seonix: digest requires repo_path\n"); process.exit(2); }
-  const modules = Array.isArray(args.modules) ? args.modules.slice(0, DIGEST_MODULE_CAP) : [];
+  let modules = Array.isArray(args.modules) ? args.modules.slice(0, DIGEST_MODULE_CAP) : [];
+  let autoSelected = null; // for the header, when `query` drove selection
+  if (!modules.length && args.query) {
+    const graph = parseEntities(await source.fetchEntities(configFor(repoPath)));
+    const ranked = searchModulesRanked(graph, args.query);
+    const scoreGapK = args.score_gap === false ? null : (Number.isFinite(args.score_gap) ? args.score_gap : DEFAULT_SCORE_GAP);
+    modules = selectRankedModules(ranked, { top_k: Number.isFinite(args.top_k) ? args.top_k : 2, scoreGapK }).slice(0, DIGEST_MODULE_CAP);
+    autoSelected = modules;
+    if (!modules.length) process.stderr.write(`seonix: digest query "${args.query}" matched no modules — empty digest\n`);
+  }
   // Tuning-flag contract (threaded to buildContextBundle → sizeBundle): `min` → leanest TINY/no
-  // top-up; `untuned` → pre-B010 escalation. Neither → the tuned default. The digest header still
+  // top-up; `untuned` → the earlier escalation. Neither → the tuned default. The digest header still
   // reports the EFFECTIVE tier/topup returned per module, so rig telemetry stays correct.
   const min = Boolean(args.min);
   const untuned = Boolean(args.untuned);
+  // seonix-max: the injection CEILING — every requested module gets a FULL (untrimmed) bundle,
+  // not just the primary + 2 trimmed secondaries. Tests whether maximal injection re-bloats.
+  const max = Boolean(args.max);
+  const secondaryCap = max ? modules.length : DIGEST_SECONDARY_CAP;
   const config = configFor(repoPath);
   const body = [];
   let effTier = "NONE"; // largest tier emitted across all modules
@@ -71,7 +102,7 @@ async function runDigest(args) {
 
   const emit = async (m, trim) => {
     try {
-      const { text, tier, topup: t } = await buildContextBundle({ symbol: m, min, untuned }, { config, source, trim });
+      const { text, tier, topup: t } = await buildContextBundle({ symbol: m, min, untuned, max }, { config, source, trim });
       body.push(`\n# Context bundle: ${m}${trim ? " (secondary, trimmed)" : ""}\n` + text);
       if ((TIER_RANK[tier] || 0) > (TIER_RANK[effTier] || 0)) effTier = tier;
       if (t) topup = true;
@@ -89,15 +120,18 @@ async function runDigest(args) {
       try { ranked = rankModulesByProximity(parseEntities(await source.fetchEntities(config)), primary, rest); }
       catch { ranked = rest; }
     }
-    const secondaries = ranked.slice(0, DIGEST_SECONDARY_CAP);
-    const overflow = ranked.slice(DIGEST_SECONDARY_CAP);
+    const secondaries = ranked.slice(0, secondaryCap);
+    const overflow = ranked.slice(secondaryCap);
     await emit(primary, false);
-    for (const m of secondaries) await emit(m, true);
+    for (const m of secondaries) await emit(m, max ? false : true);
     if (overflow.length) body.push(`\n# Related modules (not expanded; query seonix_context if needed): ${overflow.join(", ")}`);
   }
 
-  // HARD CONTRACT: first line is the machine-readable digest header the rig greps.
-  const header = `# seonix-digest tier=${effTier} topup=${topup} modules=${emitted}`;
+  // HARD CONTRACT: first line is the machine-readable digest header the rig greps. Fields are
+  // append-only — `selected=` is new (query mode only) and never changes the existing ones the
+  // rig's own parser depends on.
+  const header = `# seonix-digest tier=${effTier} topup=${topup} modules=${emitted}`
+    + (autoSelected ? ` selected=${autoSelected.join(",") || "(none)"}` : "");
   process.stdout.write([header, ...body].join("\n") + "\n");
 }
 
@@ -152,7 +186,7 @@ async function main() {
         process.exit(2);
       }
       const t0 = Date.now();
-      const { graphFile, counts } = await indexRepository(repoPath);
+      const { graphFile, counts } = await indexRepository(repoPath, { ignores: args.ignores !== false });
       process.stderr.write(
         `seonix: indexed ${counts.modules} modules, ${counts.functions} symbols, ` +
           `${counts.edges} edges (${counts.callsSymbol} callsSymbol, ${counts.touchesSymbol} touchesSymbol), ` +
@@ -189,7 +223,14 @@ async function main() {
       const config = configFor(args.repo_path);
       try {
         const graph = parseEntities(await source.fetchEntities(config));
-        const ranked = searchModulesRanked(graph, args.query || "");
+        // B016 recall-lever flags (LOCATE-phase, per-arm; output byte-identical when absent).
+        const ranked = searchModulesRanked(graph, args.query || "", {
+          demoteNonProd: !!args.demote_nonprod, // R1a: demote examples//fixtures//test-* paths
+          callAdjacency: !!args.call_adjacency, // E1a: resolved-call adjacency bonus
+          implOfInterface: !!args.impl_of_interface, // E1b: C# impl-of-interface boost
+          beamSearch: !!args.beam_search, // §5.15: multi-ply discriminative expansion
+          ...(Number.isFinite(Number(args.beam_width)) ? { beamWidth: Number(args.beam_width) } : {}),
+        });
         process.stdout.write(ranked.map((r) => `${r.path}\t${r.score}`).join("\n") + "\n");
       } catch (e) {
         process.stderr.write(`seonix: ${e?.message || e}\n`);
@@ -198,6 +239,48 @@ async function main() {
       return;
     }
 
+    // browser_link (Chronograph P2): NL-ish text → query grammar → SELF-TESTED URL.
+    // The mapping is deterministic keyword handling (nlToQuery — never a model call;
+    // a model-driven wrapper can sit on top and pass `grammar:true` with grammar it
+    // wrote itself). The link is printed ONLY if it will render something: the query
+    // must match ≥1 node of the local temporal graph and every cursor must resolve —
+    // the agent contract from PLAN_CODE_BROWSER.md ("no dead links").
+    if (sub === "browser_link") {
+      const args = parsePayload(payload);
+      if (args === null || !String(args?.query || "").trim()) {
+        process.stderr.write("seonix: browser_link expects a JSON arg, e.g. '{\"query\":\"classes that change with render\"}'\n");
+        process.exit(2);
+      }
+      const config = configFor(args.repo_path);
+      const { buildTemporalGraph, gitCommitOrder } = await import("../src/browser.mjs");
+      const { nlToQuery, validateLink, encodeViewState, VIEW_DEFAULTS } = await import("../src/temporal.mjs");
+      try {
+        const raw = await source.fetchEntities(config);
+        const commitIds = (raw.individuals || []).filter((i) => i.class === "Commit").map((i) => i.id);
+        const order = await gitCommitOrder(args.repo_path || process.cwd(), commitIds);
+        const tg = buildTemporalGraph(raw, order, { scope: args.scope });
+        const { q, notes } = args.grammar ? { q: String(args.query).trim(), notes: [] } : nlToQuery(args.query);
+        for (const n of notes) process.stderr.write(`seonix: note: ${n}\n`);
+        if (!q) {
+          process.stderr.write("seonix: the request maps to an empty query — nothing to link\n");
+          process.exit(1);
+        }
+        const v = validateLink(tg, { q, at: args.at || "", b: args.b || "" });
+        if (!v.ok) {
+          for (const r of v.reasons) process.stderr.write(`seonix: link self-test FAILED: ${r}\n`);
+          process.exit(1);
+        }
+        const qs = encodeViewState({ ...VIEW_DEFAULTS, q, at: args.at || "", b: args.b || "" });
+        const base = String(args.base || "").replace(/\/+$/, "");
+        process.stdout.write(`${base}/code-browser.html?${qs}\n`);
+        process.stderr.write(`seonix: link self-test OK — q="${q}" matches ${v.matches} node(s)\n`);
+      } catch (e) {
+        process.stderr.write(`seonix: ${e?.message || e}\n`);
+        process.exit(1);
+      }
+      return;
+    }
+
     // tool-query fallback: any other `cli <toolName> '{…}'` routes to the MCP dispatcher,
     // so "cold" tools are invokable from Bash without an MCP connection.
     if (sub) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/seonix",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "description": "SEONIX — a deterministic, offline, $0 code-graph tool that makes a cheap coding agent edit like an expensive one. Indexes a repo with Python ast + git (zero model calls) and renders a bounded edit-digest.",
@@ -45,7 +45,10 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "cytoscape": "^3.30.0",
-    "ts-morph": "^24.0.0"
+    "ts-morph": "^24.0.0",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-c-sharp": "^0.21.3",
+    "tree-sitter-java": "^0.21.0"
   },
   "scripts": {
     "test": "node --test \"test/**/*.test.mjs\"",

package/src/ask-vocab.mjs

@@ -0,0 +1,258 @@
+// ask-vocab.mjs — the single committed vocabulary `ask.mjs`'s grammar, rephrase
+// hint, and renderer noun forms all derive from (§3 of PLAN_MECHANICAL_CHAT.md).
+// A shipped, hand-curated resource — the same "closed is deliberate" ethos as
+// this repo's other closed vocabularies (SEON/mgx predicates, `.seonixignore`'s
+// gitignore-subset grammar): an open/unbounded phrase list is unvalidatable and
+// eventually produces a false-positive match against an unrelated code
+// identifier, so each relation carries a curated (not exhaustive) set of real
+// phrasings a developer would type, not a general-English thesaurus dump.
+//
+// Modeled on marginalia's app/lib/vocab.mjs pattern (a single source of truth
+// with a `verbs: [...]` trigger-phrase array per token) — minus the RDF/OWL
+// external-alignment machinery, which doesn't apply here: seonix's vocabulary
+// is code-relationship-specific (imports/calls/inherits/…), not a general
+// knowledge-graph ontology. No NLP library, no lemmatiser — plain phrase lists
+// feeding the same fixed-precedence regex grammar `ask.mjs` already used, so
+// broadening coverage never risks the "closed, deterministic, zero model
+// calls" contract this repo holds at every layer (extraction through query).
+
+/** relation token -> { comment, verbs[] }. Every phrase in `verbs` must be
+ *  something a developer would plausibly type asking about THIS relation in
+ *  THIS codebase's terms — not a synonym so generic it risks matching an
+ *  unrelated question (see the file-level comment; judgment calls on omitted
+ *  phrases are logged inline below, not silently dropped).
+ *
+ *  Register spread (2026-07-02, ELIZA/PARRY-style breadth, PLAN_MECHANICAL_CHAT.md
+ *  §3.5): each relation's `verbs` list deliberately spans formal, neutral, and
+ *  casual/colloquial phrasings — not just formal synonyms — because the value of
+ *  a keyword-spotting matcher is SURFACE-FORM tolerance for the same underlying
+ *  intent, not narrow correctness. Registers are grouped with an inline comment
+ *  per relation rather than a per-phrase tag (kept flat, matching marginalia's
+ *  `verbs: [...]` shape) since ask.mjs only needs phrase -> kind, never the
+ *  register itself. A misparsed casual phrase costs nothing beyond an honest
+ *  object-miss (resolveObject never guesses), so breadth here is genuinely low-risk. */
+export const RELATIONS = {
+  imports: {
+    comment: "Module -> Module: subject's import graph references object (usesComplexType).",
+    verbs: [
+      // formal/neutral
+      "couples to", "couple to", "uses", "use", "depends on", "imports", "import",
+      "relies on", "rely on", "requires", "require", "references", "reference",
+      "pulls in", "pull in", "built on", "builds on", "build on", "uses code from",
+      // casual/colloquial
+      "grabs", "grab", "pulls from", "pull from", "leans on", "lean on",
+      "is wired to", "are wired to", "is hooked up to", "are hooked up to",
+      // gerund (g-drop normalization turns dialectal "importin'" into this — §3.5)
+      "importing",
+    ],
+  },
+  calls: {
+    comment: "Function/Method -> Function/Class (symbol-grain) or Module -> Module (coarse): subject invokes object.",
+    verbs: [
+      // formal
+      "invokes", "invoke",
+      // neutral
+      "calls", "call", "runs", "run", "executes", "execute",
+      // casual/colloquial
+      "hits", "hit", "triggers", "trigger", "fires", "fire", "kicks off", "kick off",
+      // gerund (g-drop normalization turns dialectal "callin'" into this — §3.5)
+      "calling",
+    ],
+  },
+  defines: {
+    comment: "Module -> top-level Function/Class/Method/Attribute: subject declares object.",
+    verbs: [
+      "defines", "define", "declares", "declare",
+      "has", "have", "holds", "hold",
+      // gerund (g-drop normalization — §3.5)
+      "defining",
+    ],
+  },
+  contains: {
+    comment: "Class -> Method/Attribute: subject's membership includes object.",
+    verbs: [
+      "contains", "contain", "lives in", "live in", "is defined in", "are defined in",
+      "is part of", "are part of", "sits in", "sit in", "sits inside", "sit inside",
+      // gerund (g-drop normalization — §3.5)
+      "containing",
+    ],
+  },
+  tests: {
+    comment: "Module -> Module: subject is a test module importing/covering object.",
+    verbs: [
+      "tests", "test", "covers", "cover", "verifies", "verify", "exercises", "exercise",
+      "checks", "check", "makes sure of", "make sure of",
+      // gerund (g-drop normalization — §3.5)
+      "testing",
+    ],
+  },
+  inherits: {
+    comment: "Class -> Class: subject's declared base resolves to object (subclassOf).",
+    verbs: [
+      "inherits from", "inherit from", "extends", "extend", "subclasses", "subclass",
+      "derives from", "derive from", "is a subclass of", "are a subclass of",
+      "is a kind of", "are a kind of", "is built off", "are built off",
+      "is built on top of", "are built on top of",
+      // gerund (g-drop normalization — §3.5)
+      "extending",
+    ],
+  },
+  touches: {
+    comment: "Commit -> Module (coarse) or Commit -> symbol (fine, touchesSymbol): a commit's changed-line-range intersects object.",
+    verbs: [
+      "touched", "touches", "changed", "change", "modified", "modifies",
+      "was changed in", "were changed in", "was edited in", "were edited in",
+      "was modified by", "were modified by", "was tweaked in", "were tweaked in",
+      "got changed in", "got edited in",
+      // gerund (g-drop normalization — §3.5)
+      "touching",
+    ],
+  },
+  cochange: {
+    comment: "Module -> Module: subject and object are frequently committed together (changeCoupledWith).",
+    verbs: [
+      "changed with", "co-changes with", "co-change with", "changes alongside",
+      "change alongside", "shares commits with", "share commits with",
+      "tends to change together with", "tend to change together with",
+      "moves together with", "move together with",
+    ],
+  },
+  reexports: {
+    comment: "Module -> Module: subject re-exports a name it imported from object.",
+    verbs: [
+      "exports", "export", "re-exports", "re-export", "passes through", "pass through",
+      // gerund (g-drop normalization — §3.5)
+      "exporting",
+    ],
+  },
+};
+
+/** relation token -> flat verb-phrase list, the shape ask.mjs's VERB_TO_KIND
+ *  table needs (phrase -> kind), derived once from RELATIONS. */
+export const VERB_TO_KIND = Object.freeze(
+  Object.fromEntries(
+    Object.entries(RELATIONS).flatMap(([kind, { verbs }]) => verbs.map((v) => [v, kind])),
+  ),
+);
+
+export const ENTITY_TO_TYPE = Object.freeze({
+  function: "Function", functions: "Function",
+  method: "Method", methods: "Method",
+  class: "Class", classes: "Class",
+  module: "Module", modules: "Module", file: "Module", files: "Module",
+  attribute: "Attribute", attributes: "Attribute", field: "Attribute", fields: "Attribute",
+  variable: "GlobalVariable", variables: "GlobalVariable", global: "GlobalVariable", globals: "GlobalVariable",
+  commit: "Commit", commits: "Commit",
+});
+
+export const MODIFIER_TO_KIND = Object.freeze({
+  explicitly: "direct", directly: "direct",
+  transitively: "transitive", indirectly: "transitive",
+});
+
+// ---- §3.5 normalization — contractions/informal spellings that would otherwise
+// block a match, expanded BEFORE parsing (BOTH the anchored-template strategy
+// and the independent keyword-spotting strategy see the same normalized text —
+// this table is not owned by either). Small and code-question-scoped, not a
+// general slang dictionary — every entry here exists because it appears in an
+// actual worked example this file's matcher must handle. ----
+export const CONTRACTIONS = Object.freeze({
+  "ain't": "is not", "aint": "is not",
+  "isn't": "is not", "isnt": "is not",
+  "aren't": "are not", "arent": "are not",
+  "doesn't": "does not", "doesnt": "does not",
+  "don't": "do not", "dont": "do not",
+  "didn't": "did not", "didnt": "did not",
+  "there's": "there is", "theres": "there is",
+  "what's": "what is", "whats": "what is",
+  "who's": "who is", "whos": "who is",
+  "gonna": "going to",
+  "wanna": "want to",
+  "gotta": "got to",
+  "yer": "your", "ur": "your",
+  "gimme": "give me",
+});
+
+/** Trailing g-drop ("callin'", "hittin'") — a plain suffix restore, not a
+ *  lemmatiser: -in' -> -ing, applied per-word during normalization. The
+ *  apostrophe is REQUIRED (not optional): bare "-in" endings with no
+ *  apostrophe are real English words far more often than dropped g's
+ *  ("cabin", "robin", "chin", "twin") — restoring those would be a false
+ *  positive the anchored templates never had to worry about. No trailing
+ *  `\b` after the apostrophe: `'` is a non-word character, so a `\b` there
+ *  can never match the (non-word) whitespace/end-of-string that follows —
+ *  the apostrophe itself already delimits the word, a second boundary check
+ *  after it is redundant and unmatchable. */
+export const G_DROP = /\b([a-z]{3,})in'/gi;
+
+/** Words stripped during normalization/keyword-spotting once they carry no
+ *  grammatical weight for this grammar — greetings, politeness, hedges, and
+ *  the discourse fillers a spoken-style question picks up. Never strips a
+ *  relation verb, entity noun, or modifier (those are checked first). */
+export const FILLER_WORDS = Object.freeze([
+  "um", "uh", "erm", "so", "like", "yo", "hey", "bru", "bro", "fam", "mate",
+  "please", "could you", "can you", "would you", "tell me", "i wonder",
+  "just wondering", "quickly", "real quick", "kinda", "sorta",
+]);
+
+/** Deictic/pronoun terms that refer to a context entity rather than naming one
+ *  directly — resolved against an optional `contextId` (ask.mjs §keyword-
+ *  spotting; wired from the graph viewer's currently-selected node, when the
+ *  chat panel is asking "about" whatever the user last clicked). With no
+ *  context available (the bare CLI/MCP surface), these produce an honest
+ *  "which node does 'this' refer to?" miss — never a guess. */
+export const CONTEXT_PRONOUNS = Object.freeze(["this", "it", "that", "here", "this one", "that one"]);
+
+// ---- §3.6 negation frames — a SMALL, pattern-based set of recognized
+// double-negative / negative-rhetorical constructions, normalized to the
+// affirmative form of the SAME question (not a general negation-scope parser
+// — ELIZA/PARRY's own scope discipline: a handful of recognized frames, not
+// an attempt at full logical negation handling). Each frame is tried in
+// order; the first match rewrites the whole string and normalization stops
+// (a second negation frame firing on an already-rewritten string would be a
+// design smell, not a feature). ----
+export const NEGATION_FRAMES = Object.freeze([
+  // "there ain't nothin' calling it" / "there isn't nothing that calls it"
+  //   -> "what calls it"
+  { re: /\bthere\s+is\s+not\s+(?:anything|nothing)\s+(?:that\s+)?(\S.*)$/i, to: (m) => `what ${m[1]}` },
+  // "there's no module that imports auth" -> "what imports auth"
+  { re: /\bthere\s+is\s+no\s+\S+\s+(?:that\s+)?(\S.*)$/i, to: (m) => `what ${m[1]}` },
+  // "isn't there anything calling it" -> "what calls it" (question-inverted form)
+  { re: /\bis\s+not\s+there\s+(?:anything|nothing)\s+(?:that\s+)?(\S.*)$/i, to: (m) => `what ${m[1]}` },
+  // "nobody/nothing calls it, does it" (tag-question double-negative) -> "what calls it"
+  { re: /\b(?:nobody|nothing|no one)\s+(\S.*?)(?:,?\s+does\s+it\??|,?\s+do\s+they\??)?$/i, to: (m) => `what ${m[1]}` },
+]);
+
+// ---- §7 meta-vocabulary — trigger phrases for the "meta" query shape (asking what a
+// graph vocabulary term itself means: "what does cochange mean", "what does mgx:
+// callsSymbol mean"). Deliberately NOT folded into RELATIONS/VERB_TO_KIND: these
+// phrases don't name a graph relation kind for edgesOfKind to traverse, they name
+// "explain this term" intent. Adding them to VERB_TO_KIND would make
+// parseKeywordSpot's decomposition matcher independently derive a *different* shape
+// ("forward", the only shape its before-only-text case produces) for the very same
+// sentence the anchored meta template resolves to shape:"meta" — a spurious strategy
+// DISAGREEMENT (ambiguousParse) on every meta question. So this table is read directly
+// by ask.mjs's own meta template, never merged into the shared verb tables. ----
+export const META_MEANING_VERBS = Object.freeze([
+  "mean", "means", "stand for", "stands for", "signify", "signifies",
+  "represent", "represents", "refer to", "refers to",
+]);
+
+// ---- omitted-on-purpose (judgment calls, not oversights) -------------------
+// "runs"/"executes" (calls) are common English words with many non-code
+// senses — accepted anyway, formal-template AND keyword-spotting alike,
+// because a misparse costs nothing beyond an honest object-miss
+// (resolveObject never guesses); the risk is bounded by the render layer,
+// not by narrowing the vocabulary.
+// NOT added: "needs"/"wants" for imports (too weakly code-specific — "which
+// modules need auth" reads as a feature request, not a graph query, in a way
+// "which modules depend on auth" doesn't); "wraps"/"decorates" for calls (a
+// real but distinct relationship codegraph.mjs doesn't classify separately —
+// adding the phrase would silently misroute it onto plain call edges);
+// "belongs to" for contains (already claimed by a hypothetical membership
+// verb elsewhere — kept out to avoid a future collision if one is added).
+// NOT added: a cochange gerund ("co-changing with") — every cochange phrase
+// is already 2-3 words with its own internal "-ing"/"-s" (e.g. "changes
+// alongside"), so g-drop normalization has no bare stem to dialectally
+// contract in the first place; only relations with a genuinely bare-verb
+// casual form ("call", "touch") needed one.