@polycode-projects/seonix 0.10.11 → 0.10.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/seonix",
-  "version": "0.10.11",
+  "version": "0.10.16",
   "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.",
@@ -50,6 +50,7 @@
     "setup": "node scripts/setup.mjs",
     "bench": "node bench/run.mjs",
     "bench:quick": "node bench/run.mjs --instances 1 --runs 1",
+    "bench:telemetry": "node bench/run.mjs --suite django-lh --arms seonix --instances 1 --runs 1 --telemetry",
     "join:telemetry": "node scripts/join-telemetry.mjs",
     "bench:lite": "node bench/run.mjs --suite lite",
     "bench:seonix": "node bench/run.mjs --suite django-lh --arms seonix,seonix-min --runs 5",
@@ -88,7 +89,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@polycode-projects/the-mechanical-code-talker": "^0.9.11",
+    "@polycode-projects/the-mechanical-code-talker": "^1.0.4",
     "cytoscape": "^3.30.0",
     "smol-toml": "^1.7.0",
     "tree-sitter": "^0.21.1",

package/src/ask-browser.bundle.js

@@ -590,6 +590,10 @@
     "touchs": "touches",
     "tuoches": "touches",
     "touhced": "touched",
+    // WHERE_MARKERS typo (0.9.13 Tier-1 playtest): "defined" itself had no typo
+    // entry, so "where is it defned" fell through to the bare-object search path
+    // instead of the where-shape ("no module matching 'it defned' found").
+    "defned": "defined",
     "chagned": "changed",
     "chnaged": "changed",
     "chagnes": "changes",
@@ -602,6 +606,17 @@
     "whcih": "which",
     "wich": "which",
     "whihc": "which",
+    // "wehre"/"whre" (0.9.13 Tier-1 playtest, "where is it defined" drill-down):
+    // the WHERE-DEFINED shape's own anchor word had NO typo tolerance at all
+    // (unlike which/what/does/the above), so a plain dropped/transposed letter
+    // fell straight through resolveObject and hit either the grammar wall or a
+    // bogus "no module matching 'it defined'" search. "were" (the missing-h
+    // homophone slip) is NOT curated here — it's a real word already load-bearing
+    // as the TEMPORAL_AUX auxiliary ("when were the modules last touched"), so
+    // that one typo is handled by its own anchored phrasing frame instead
+    // (normalize.mjs PHRASING_FRAMES) to avoid clobbering the legitimate reading.
+    "wehre": "where",
+    "whre": "where",
     // "wat" (chatbench cycle 2, tf-wat-calls): the internet-casual spelling of
     // "what" — neither curated noise nor a restorable trigger typo, so "wat calls
     // fnAlpha" used to die as "couldn't resolve one of the terms". Restored here
@@ -685,7 +700,8 @@
     "kinda",
     "sorta",
     "btw",
-    "by the way"
+    "by the way",
+    "you"
   ]);
   var CONTEXT_PRONOUNS = Object.freeze(["this", "it", "that", "here", "this one", "that one"]);
   var NEGATION_FRAMES = Object.freeze([
@@ -992,9 +1008,10 @@
     const words = rest.replace(/\?+\s*$/, "").trim().split(/\s+/);
     return LISTING_TAIL_KINDS.has((words[words.length - 1] || "").toLowerCase());
   };
-  var GREETING_PREAMBLE_RE = /^(?:hi|hiya|hello|hey|yo|howdy)(?:\s+there)?\s*[,—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
+  var GREETING_PREAMBLE_RE = /^(?:hi|hiya|hello|hey|yo|howdy|g'?day|good\s+(?:morning|afternoon|evening|day)|greetings|salutations)(?:\s+there)?\s*[,.—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
   var THANKS_PREAMBLE_RE = /^(?:thanks|thank\s+you|many\s+thanks|thx|ty|cheers)(?:\s+(?:so\s+much|a\s+lot|very\s+much|a\s+bunch))?\s*[,—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
   var MODAL_WRAPPER_RE = /^(?:can|could|would|will)\s+you\s+(?:please\s+)?(.+?)(?:[,\s]+please)?\??$/i;
+  var EXPLAIN_WRAPPER_RE = /^explain\s+(?:to\s+me\s+|please\s+)*(.+?)\??$/i;
   var SHOW_GIVE_ME_RE = /^(?:show|give)\s+me\s+(?:the\s+)?(.+?)\??$/i;
   function applyPreambleFrames(text) {
     let q = String(text || "");
@@ -1006,6 +1023,8 @@
       if (m) q = m[1].trim();
       m = q.match(MODAL_WRAPPER_RE);
       if (m) q = m[1].trim();
+      m = q.match(EXPLAIN_WRAPPER_RE);
+      if (m && INTERROGATIVE_LEAD_RE.test(m[1].trim())) q = m[1].trim();
       m = q.match(SHOW_GIVE_ME_RE);
       if (m) {
         const rest = m[1].trim();
@@ -1027,6 +1046,18 @@
     }
     return q;
   }
+  var SELF_CORRECTION_RE = /^.+?(?:\s*(?:--|—|-)\s*)?\b(?:sorry|i\s+mean)\b\s*(?:--|—|-|,|:)\s*(.+)$/i;
+  function applySelfCorrectionFrames(text) {
+    let q = String(text || "");
+    for (let pass = 0; pass < 3; pass++) {
+      const m = q.match(SELF_CORRECTION_RE);
+      if (!m) break;
+      const next = m[1].trim();
+      if (!next || next === q) break;
+      q = next;
+    }
+    return q;
+  }
   var CONDITIONAL_VERB_GERUND = Object.freeze({
     imports: "importing",
     calls: "calling",
@@ -1073,6 +1104,7 @@
     q = q.replace(WRONG_WORD_RE, (m) => WRONG_WORDS[m.toLowerCase()]);
     q = q.replace(G_DROP, "$1ing");
     q = applyPreambleFrames(q);
+    q = applySelfCorrectionFrames(q);
     q = applySubordinationFrames(q);
     q = applyConditionalFrames(q);
     if (FILLER_WORDS.length) {
@@ -1111,6 +1143,15 @@
     { re: /^what\s+(?:defined|declared)\s+(?:the\s+)?(?:function\s+|method\s+|class\s+|module\s+|variable\s+|constant\s+)?(.+?)\??$/i, to: (m) => `where is ${m[1]} defined` },
     //   "where's X defined" (the "where's" contraction is not in the contraction table)
     { re: /^where'?s\s+(?:the\s+)?(.+?)\s+(defined|declared|located|implemented)\??$/i, to: (m) => `where is ${m[1]} ${m[2]}` },
+    //   "were is X defined" (0.9.13 Tier-1 playtest: the missing-h typo of "where").
+    //   NOT curated as a blanket MISSPELLINGS entry — "were" is a real word already
+    //   load-bearing as the TEMPORAL_AUX auxiliary ("when were the modules last
+    //   touched"), so a global word-boundary rewrite would clobber that reading.
+    //   This frame is anchored to the WHERE-DEFINED shape specifically ("were is
+    //   … defined/declared/located/implemented"), a construction no legitimate
+    //   temporal query produces ("were" as an auxiliary never leads directly into
+    //   a bare "is").
+    { re: /^were\s+is\s+(?:the\s+)?(.+?)\s+(defined|declared|located|implemented)\??$/i, to: (m) => `where is ${m[1]} ${m[2]}` },
     // PREDICATIVE QUALIFIER → the ATTRIBUTIVE form the grammar already answers. The
     // adjective-qualifier post-filters (ask-vocab.mjs QUALIFIERS: tested/untested,
     // public/private, exported, static/abstract/constant, …) parse in the ATTRIBUTIVE
@@ -1304,11 +1345,13 @@
     return /^[a-z]+$/.test(w) && !STOPWORDS2.has(w) && !VOCAB_WORDS.has(w);
   }
   function fuzzyVocabWord(w) {
-    const bound = fuzzyBound(w);
+    return fuzzyMatchInSet(w, FUZZY_TARGET_WORDS, fuzzyBound(w));
+  }
+  function fuzzyMatchInSet(w, candidates, bound = fuzzyBound(w)) {
     let best = bound + 1;
     let hit2 = null;
     let tied = false;
-    for (const target of FUZZY_TARGET_WORDS) {
+    for (const target of candidates) {
       const d = editDistance(w, target, Math.min(best, bound));
       if (d < best) {
         best = d;
@@ -2281,7 +2324,7 @@
   }
   var MAX_COMPOSE_DEPTH = 4;
   var NEST_SENTINEL = "zzinnerset";
-  var PRED_LEAD_SKIP = /* @__PURE__ */ new Set(["that", "which", "who", "are", "is", "was", "were", "do", "does", "also", "still", "both", "and"]);
+  var PRED_LEAD_SKIP = /* @__PURE__ */ new Set(["that", "which", "who", "are", "is", "was", "were", "do", "does", "also", "still", "both", "and", "then", "though"]);
   var FRAME_WORDS = /* @__PURE__ */ new Set(["which", "what", "who", "list", "show", "find", "give", "me", "us", "all"]);
   var entityNoun = (w) => ENTITY_TO_TYPE[w] ? { entityType: ENTITY_TO_TYPE[w], placeholder: false } : PLACEHOLDER_NOUNS.includes(w) ? { entityType: null, placeholder: true } : null;
   var isGerundVerb = (w) => !!VERB_TO_KIND[w] && w.endsWith("ing");
@@ -2291,7 +2334,7 @@
   function parseComposite(text, nlp) {
     const w = splitWords(text);
     const lc = w.map((x) => x.toLowerCase());
-    return parseNegation(text, nlp, 0) || parseForwardNegation(w, lc, nlp) || parseTemporal(w, lc, nlp, 0) || parseAnaphora(w, lc, nlp) || parseAggregate(w, lc, nlp) || parseSuperlative(w, lc, nlp) || parseFind(w, lc, nlp, 0) || parseList(w, lc, nlp, 0) || parseNested(w, lc, nlp, 0) || parseRelationalOrQualified(w, lc, nlp, 0);
+    return parseExistence(w, lc) || parseNegation(text, nlp, 0) || parseForwardNegation(w, lc, nlp) || parseTemporal(w, lc, nlp, 0) || parseAnaphora(w, lc, nlp) || parseAggregate(w, lc, nlp) || parseSuperlative(w, lc, nlp) || parseFind(w, lc, nlp, 0) || parseList(w, lc, nlp, 0) || parseNested(w, lc, nlp, 0) || parseRelationalOrQualified(w, lc, nlp, 0);
   }
   function complementAst(entityType, diffAtom) {
     return {
@@ -2441,6 +2484,9 @@
     return { node: "temporal", inner, entityType: noun && noun.entityType || null };
   }
   function parseAnaphora(w, lc, nlp) {
+    if (lc.length === 2 && lc[0] === "which" && (lc[1] === "ones" || lc[1] === "one")) {
+      return { node: "anaphora", mode: "list", filter: { type: "all" } };
+    }
     let p = -1;
     let viaOf = false;
     for (let i = 1; i < lc.length; i += 1) {
@@ -2477,6 +2523,46 @@
     }
     return void 0;
   }
+  function parseExistence(w, lc) {
+    let i;
+    if (lc[0] === "is" && lc[1] === "there") i = 2;
+    else if (lc[0] === "are" && lc[1] === "there") i = 2;
+    else return null;
+    const article = lc[i];
+    if (article === "a" || article === "an" || article === "any") i += 1;
+    else return null;
+    const noun = i < lc.length ? entityNoun(lc[i]) : null;
+    if (!noun || noun.placeholder || !noun.entityType) return null;
+    const entityType = noun.entityType;
+    i += 1;
+    let rest = lc.slice(i);
+    let restW = w.slice(i);
+    if (rest.length && rest[rest.length - 1] === "anywhere") {
+      rest = rest.slice(0, -1);
+      restW = restW.slice(0, -1);
+    } else if (rest.length >= 2 && rest[rest.length - 2] === "at" && rest[rest.length - 1] === "all") {
+      rest = rest.slice(0, -2);
+      restW = restW.slice(0, -2);
+    }
+    if (!rest.length) return { node: "exists", entityType, term: null, scopeModule: null };
+    if (rest[0] === "called" || rest[0] === "named") {
+      if (rest.length < 2) return { node: "miss", reason: `"${rest[0]}" needs a name afterward` };
+      const inIdx = rest.indexOf("in", 1);
+      if (inIdx > 0) {
+        const term2 = restW.slice(1, inIdx).join(" ").trim();
+        const scopeModule = restW.slice(inIdx + 1).join(" ").trim();
+        if (!term2 || !scopeModule) return { node: "miss", reason: `a named existence check needs both a name and a module after "in"` };
+        return { node: "exists", entityType, term: term2, scopeModule };
+      }
+      const term = restW.slice(1).join(" ").trim();
+      return term ? { node: "exists", entityType, term, scopeModule: null } : { node: "miss", reason: `"${rest[0]}" needs a name afterward` };
+    }
+    if (rest[0] === "in") {
+      const scopeModule = restW.slice(1).join(" ").trim();
+      return scopeModule ? { node: "exists", entityType, term: null, scopeModule } : { node: "miss", reason: `"in" needs a module afterward` };
+    }
+    return null;
+  }
   var AGG_TAIL_FILLER = /* @__PURE__ */ new Set([
     "total",
     "altogether",
@@ -2492,7 +2578,9 @@
     "index",
     "codebase",
     "repo",
-    "repository"
+    "repository",
+    "this",
+    "that"
   ]);
   function parseAggregate(w, lc, nlp) {
     const trig = AGGREGATE_TRIGGERS.find((t) => lc.slice(0, t.split(" ").length).join(" ") === t);
@@ -2524,6 +2612,7 @@
   var LIST_SKIP = /* @__PURE__ */ new Set(["the", "a", "an", "all", "me", "us"]);
   var LIST_TRIGGERS_SORTED = [...LIST_TRIGGERS].sort((a, b) => b.split(" ").length - a.split(" ").length);
   var LISTABLE_KINDS = "functions, classes, methods, modules, attributes, variables, or commits";
+  var SCOPE_PREPOSITIONS = /* @__PURE__ */ new Set(["in", "inside", "under"]);
   function parseList(w, lc, nlp, depth) {
     let i = 0;
     let interrogative = false;
@@ -2560,11 +2649,19 @@
     i += 1;
     const tail = w.slice(i);
     const tailMeaningful = lc.slice(i).some((t) => !STOPWORDS2.has(t) && !AGG_TAIL_FILLER.has(t));
-    if (interrogative && (tailMeaningful || tail.length === 0)) return null;
+    let scopeTailLc = lc.slice(i);
+    let scopeTailWords = tail;
+    if (scopeTailLc[0] === "is" || scopeTailLc[0] === "are") {
+      scopeTailLc = scopeTailLc.slice(1);
+      scopeTailWords = scopeTailWords.slice(1);
+    }
+    const scopedException = interrogative && SCOPE_PREPOSITIONS.has(scopeTailLc[0]);
+    if (interrogative && (tailMeaningful && !scopedException || tail.length === 0)) return null;
     let base;
     let scoped = false;
     if (tailMeaningful) {
-      const setAst = parseSetPhrase(`which ${[...quals, entWord, ...tail].join(" ")}`, nlp, (depth || 0) + 1);
+      const useTail = scopedException ? scopeTailWords : tail;
+      const setAst = parseSetPhrase(`which ${[...quals, entWord, ...useTail].join(" ")}`, nlp, (depth || 0) + 1);
       if (!setAst || setAst.node === "miss") return { node: "miss", reason: setAst && setAst.reason || "the list filter didn't parse" };
       base = setAst;
       scoped = true;
@@ -2709,7 +2806,7 @@
     const noun = i < lc.length ? entityNoun(lc[i]) : null;
     if (!noun) {
       const nextNoun = i + 1 < lc.length ? entityNoun(lc[i + 1]) : null;
-      if ((framed || quals.length) && nextNoun && /^[a-z]+$/.test(lc[i]) && !VERB_TO_KIND[lc[i]] && !STOPWORDS2.has(lc[i])) {
+      if ((framed || quals.length) && nextNoun && /^[a-z]+$/.test(lc[i]) && !VERB_TO_KIND[lc[i]] && !STOPWORDS2.has(lc[i]) && !CASCADE_NOISE_SET.has(lc[i])) {
         return { node: "find", entityType: nextNoun.entityType, term: w[i] };
       }
       return null;
@@ -3139,8 +3236,33 @@
     const winners = scored.filter((s) => s.score === best).map((s) => s.ind);
     return { compositeKind: "superlative", entityType: ast.entityType, metricNoun: ast.metricNoun, extreme: ast.extreme, score: best, matches: winners };
   }
+  function evalExists(graph, ast) {
+    const { entityType, term, scopeModule } = ast;
+    let scopeMatch = null;
+    if (scopeModule) {
+      const r = resolveObject(graph, scopeModule, { expectedClass: "Module" });
+      if (!r.match) return { compositeKind: "exists", entityType, term, scopeModule, scopeMiss: true, matches: [] };
+      scopeMatch = r.match;
+    }
+    if (term) {
+      const r = resolveObject(graph, term, { expectedClass: entityType });
+      const inScope = !scopeMatch || r.match && moduleIdOf2(graph, r.match) === scopeMatch.id;
+      const hit2 = r.match && inScope;
+      return {
+        compositeKind: "exists",
+        entityType,
+        term,
+        scopeModule,
+        scopeMatch,
+        matches: hit2 ? [r.match] : []
+      };
+    }
+    const pool = scopeMatch ? refineToEntities(graph, /* @__PURE__ */ new Set([scopeMatch.id]), entityType) : graph.individuals.filter((i) => i.class === entityType);
+    return { compositeKind: "exists", entityType, term: null, scopeModule, scopeMatch, matches: pool };
+  }
   function evalComposite(graph, ast, opts = {}) {
     if (ast.node === "miss") return { compositeMiss: true, reason: ast.reason || null, matches: [] };
+    if (ast.node === "exists") return evalExists(graph, ast);
     if (ast.node === "count") return { compositeKind: "count", count: evalSet(graph, ast.base, opts).length, entityType: ast.entityType, matches: [] };
     if (ast.node === "list") return { compositeKind: "list", matches: evalSet(graph, ast.base, opts), entityType: ast.entityType, scoped: ast.scoped };
     if (ast.node === "superlative") return evalSuperlative(graph, ast);
@@ -3175,6 +3297,27 @@
       }
       return { content: `couldn't compile this compositional question${result.reason ? ` (${result.reason})` : ""}. ${compositionalHint()}.`, miss: true, ambiguous: false };
     }
+    if (result.compositeKind === "exists") {
+      if (result.scopeMiss) {
+        return { content: `no module matching "${result.scopeModule}" found in the index.`, miss: true, ambiguous: false };
+      }
+      const kindSingular = nounFor(result.entityType, 1);
+      const kindPlural = nounFor(result.entityType, 2);
+      const scopeSuffix = result.scopeMatch ? ` in ${result.scopeMatch.label}` : "";
+      if (result.term) {
+        if (!result.matches.length) {
+          return { content: `No \u2014 no ${kindSingular} named "${result.term}" found${scopeSuffix}.`, miss: true, ambiguous: false };
+        }
+        const hit2 = result.matches[0];
+        const modLabel = moduleLabelOf(hit2);
+        const definedIn = hit2.class === "Module" ? "" : modLabel && modLabel !== "(unknown module)" ? `, defined in ${modLabel}` : "";
+        return { content: `Yes \u2014 ${hit2.label} is a ${kindSingular}${definedIn}.`, miss: false, ambiguous: false, matches: result.matches };
+      }
+      if (!result.matches.length) {
+        return { content: `No \u2014 no ${kindPlural} found${scopeSuffix}.`, miss: true, ambiguous: false };
+      }
+      return { content: `Yes \u2014 ${compositeList(result.matches)}${scopeSuffix}.`, miss: false, ambiguous: false, matches: result.matches };
+    }
     if (result.compositeKind === "count") {
       const noun = result.entityType ? nounFor(result.entityType, result.count) : result.count === 1 ? "result" : "results";
       return { content: `${result.count} ${noun}.`, miss: false, ambiguous: false, matches: [] };
@@ -3771,7 +3914,8 @@
     }
     if (!result.objMatch && (!result.candidates || result.candidates.length === 0) && parsed.shape !== "ask") {
       const objText = String(parsed.object || "").trim();
-      const what = /^(?:commit[:\s])?[0-9a-f]{7,40}$/i.test(objText) ? "commit" : !objText.includes("/") && /^[\w$]+(\.[\w$]+)+$/.test(objText) ? "symbol" : "module";
+      const fallback = parsed.entityType && PLURAL_FORMS[parsed.entityType] ? nounFor(parsed.entityType, 1) : "module";
+      const what = /^(?:commit[:\s])?[0-9a-f]{7,40}$/i.test(objText) ? "commit" : !objText.includes("/") && /^[\w$]+(\.[\w$]+)+$/.test(objText) ? "symbol" : fallback;
       return {
         content: `no ${what} matching "${parsed.object}" found in the index.`,
         miss: true,

package/src/ask-browser.bundle.version

@@ -1 +1 @@
-0.9.11
+1.0.4

package/src/concept-digest.mjs

@@ -0,0 +1,157 @@
+// concept-digest.mjs — PROTOTYPE, not wired into any product surface (PLAN_CONCEPT_DIGEST.md).
+//
+// Extracts concept words from a task prompt (reusing prose.mjs's two tokenizer primitives, §3.1),
+// then sweeps them type-scoped across the graph for literal file:line hits (§3.2). The
+// ask()-driven ontology sweep (§3.3) and the combined two-section digest (§3.5) are NOT
+// implemented this round — see the TODOs below and PLAN_CONCEPT_DIGEST.md §6/§7.
+//
+// §3.2(b): `identComponents` below is a standalone duplicate of codegraph.mjs's private (non-
+// exported) helper of the same name — pure string manipulation, no graph-shape dependency, so
+// duplicating it carries no correctness risk. `definesIndex`'s edge lookup, by contrast, uses
+// codegraph.mjs's own EXPORTED `edgesOfKind`/`relationKind` machinery directly rather than
+// re-deriving relation classification locally — that classification (PROP_KIND, the mgx/seon
+// alias table) is exactly the kind of thing that must never drift between two copies. Only
+// `matchSymbols`-shaped per-kind scoring (§3.2(a)) is still standalone-duplicated pending the
+// codegraph.mjs refactor PLAN_CONCEPT_DIGEST.md §3.2(a)/§7 phase 2 proposes.
+
+import { splitIdentifierWords, tokenizeProse } from "./prose.mjs";
+import { siteOf, edgesOfKind } from "./codegraph.mjs";
+
+const SYMBOL_CLASSES = { function: "Function", class: "Class", method: "Method", attribute: "Attribute", route: "Route" };
+export const LITERAL_SWEEP_KINDS = ["module", "function", "class", "method", "attribute", "route"];
+
+/** §3.1: the task prompt's concept words. NOT a bare `proseTokensFor({name, doc: promptText})`
+ *  call — proseTokensFor is built for a single SYMBOL name + its doc, and its `name` half
+ *  (splitIdentifierWords) deliberately carries NO stopword filter, because a real identifier
+ *  never contains an English stopword in the first place. A whole task PROMPT is different: it
+ *  mixes ordinary stopword-laden prose with embedded identifiers ("fix Truncator.chars"), so
+ *  feeding the same full prompt text through both proseTokensFor halves re-admits "the"/"and"/
+ *  "its" via the identifier-decomposition path even though tokenizeProse already dropped them
+ *  from the prose path (caught by this file's own test suite, §6 — see the "reuses prose.mjs's
+ *  stopword filter" test). The correct composition: decompose identifiers FIRST
+ *  (splitIdentifierWords, camelCase/snake/dotted boundaries), then run the DECOMPOSED text back
+ *  through tokenizeProse so the stopword filter applies to both origins uniformly, unioned with
+ *  tokenizeProse over the raw prompt (covers plain prose words untouched by decomposition). */
+export function extractConceptWords(promptText) {
+  const prose = tokenizeProse(promptText);
+  const decomposed = tokenizeProse(splitIdentifierWords(promptText).join(" "));
+  return [...new Set([...prose, ...decomposed])].sort();
+}
+
+/** Mirrors codegraph.mjs's private `identComponents` (camelCase/snake_case boundary split) —
+ *  duplicated per the file-header note above, not imported (it is not exported there). */
+function identComponents(name) {
+  return new Set(String(name).replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
+}
+
+/** subject id -> [defined symbol labels], built off codegraph.mjs's own EXPORTED `edgesOfKind`
+ *  (which in turn uses the real `relationKind` classifier — the mgx/seon PROP_KIND alias table
+ *  lives there ONCE; this file must never re-derive it, see the file-header note above). */
+function definesIndex(graph) {
+  const idx = new Map();
+  for (const e of edgesOfKind(graph, "defines")) {
+    if (!idx.has(e.subject)) idx.set(e.subject, []);
+    idx.get(e.subject).push(e.objectLabel || e.object);
+  }
+  return idx;
+}
+
+function siteFileLine(graph, id) {
+  const ind = graph.byId?.get?.(id);
+  const site = ind ? siteOf(ind) : null;
+  return site ? { file: site.path, line: site.start } : { file: null, line: null };
+}
+
+/** One module's combined literal-match text bag: lowercased path components + every defined
+ *  symbol's name components + (when present) its `prose_tokens` attribute — the same "per-module
+ *  combined text" idiom moduleEmbedTexts/definesIndex already use in codegraph.mjs (§3.2). */
+function moduleTextBag(ind, defines) {
+  const bag = new Set();
+  for (const c of String(ind.label).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean)) bag.add(c);
+  for (const d of defines) for (const c of identComponents(d)) bag.add(c);
+  const prose = (ind.attributes || []).find((a) => a.key === "prose_tokens")?.value;
+  if (prose) for (const t of String(prose).split(/\s+/).filter(Boolean)) bag.add(t);
+  return bag;
+}
+
+/** §3.2 module-kind sweep: strict AND over each module's text bag (every concept word must be
+ *  present somewhere in the module), falling back to a coverage-ranked list when the AND-set is
+ *  empty — the same "try strict first, relax only on a genuine miss" shape as tmct's ask()
+ *  relaxation cascade (PLAN_CONCEPT_DIGEST.md §3.2). Never throws, never silently returns
+ *  nothing when SOME module matched at least one word. */
+function sweepModules(graph, conceptWords) {
+  const defIdx = definesIndex(graph);
+  const andHits = [];
+  const coverageHits = [];
+  for (const ind of graph.individuals) {
+    if ((ind.class || "") !== "Module") continue;
+    const defines = defIdx.get(ind.id) || [];
+    const bag = moduleTextBag(ind, defines);
+    const matched = conceptWords.filter((w) => bag.has(w));
+    if (!matched.length) continue;
+    const { file, line } = siteFileLine(graph, ind.id);
+    const hit = {
+      id: ind.id, label: ind.label, kind: "module", file: file || ind.label, line,
+      literalScore: matched.length, literalMatchedWords: matched, ontologyHits: [],
+    };
+    coverageHits.push(hit);
+    if (matched.length === conceptWords.length) andHits.push(hit);
+  }
+  const rank = (a, b) => b.literalScore - a.literalScore || String(a.label).length - String(b.label).length;
+  if (andHits.length) return andHits.sort(rank);
+  return coverageHits.sort(rank);
+}
+
+/** §3.2 symbol-kind sweep (function/class/method/attribute/route): coverage-ranked, NOT AND —
+ *  see PLAN_CONCEPT_DIGEST.md §3.2 for why AND is reserved for the module grain only. Mirrors
+ *  searchSymbols's own coverage-not-AND scoring shape (codegraph.mjs:1622-1656), applied per
+ *  concept word instead of per raw query token. */
+function sweepSymbols(graph, conceptWords, kind) {
+  const targetClass = SYMBOL_CLASSES[kind];
+  if (!targetClass) return [];
+  const hits = [];
+  for (const ind of graph.individuals) {
+    if ((ind.class || "") !== targetClass) continue;
+    const labelLc = String(ind.label).toLowerCase();
+    const comps = identComponents(ind.label);
+    const matched = conceptWords.filter((w) => comps.has(w) || labelLc.includes(w));
+    if (!matched.length) continue;
+    const { file, line } = siteFileLine(graph, ind.id);
+    hits.push({
+      id: ind.id, label: ind.label, kind, file, line,
+      literalScore: matched.length, literalMatchedWords: matched, ontologyHits: [],
+    });
+  }
+  return hits.sort((a, b) => b.literalScore - a.literalScore || String(a.label).length - String(b.label).length);
+}
+
+/** §3.2: the full type-specific literal sweep — module-kind AND (coverage fallback) UNION
+ *  symbol-kind coverage sweeps, one per requested kind. Returns a flat, per-kind-ranked hit list
+ *  (NOT deduped/combined with an ontology sweep — that composition is buildConceptDigest's job,
+ *  §3.5, not yet implemented — see the TODO at the bottom of this file). */
+export function literalSweep(graph, conceptWords, { kinds = LITERAL_SWEEP_KINDS } = {}) {
+  const words = [...new Set(conceptWords)];
+  if (!words.length) return [];
+  const out = [];
+  if (kinds.includes("module")) out.push(...sweepModules(graph, words));
+  for (const kind of kinds) {
+    if (kind === "module" || !SYMBOL_CLASSES[kind]) continue;
+    out.push(...sweepSymbols(graph, words, kind));
+  }
+  return out;
+}
+
+// TODO(concept-digest, ontology sweep — PLAN_CONCEPT_DIGEST.md §3.3/§7 phase 1): sentence-split
+// the prompt + templated subclass/superclass/find probes over extractConceptWords' output, run
+// through makeSeonixProvider(graph).ask(fragment) in-process (never a subprocess — §3.4), map
+// tmct_ask.matches[].id -> siteOf for file:line. Not implemented this round.
+export function ontologySweep(_graph, _promptText, _opts = {}) {
+  throw new Error("concept-digest: ontologySweep is not implemented yet — see PLAN_CONCEPT_DIGEST.md §3.3/§7");
+}
+
+// TODO(concept-digest, combine — PLAN_CONCEPT_DIGEST.md §3.5/§7 phase 1): dedupe literalSweep +
+// ontologySweep by individual id into the two-section {literal, ontology} digest + rendered text.
+// Depends on ontologySweep above; not implemented this round.
+export function buildConceptDigest(_graph, _promptText, _opts = {}) {
+  throw new Error("concept-digest: buildConceptDigest is not implemented yet — see PLAN_CONCEPT_DIGEST.md §3.5/§7");
+}

package/src/extract.mjs

@@ -438,21 +438,35 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
       }
 
       // symbol-granular calls: caller fn/method → callee fn/class/method. The top-level
-      // function/class registry resolves first, unchanged (exactly ONE in-repo definition —
-      // same unique-name discipline as the module-coarse calls). On a complete miss there,
-      // receiver-typed call texts fall through to the tiered METHOD registry above, so
-      // `_svc.ProcessOrder(...)` reaches `B.ProcessOrder` even though no top-level symbol
-      // carries that name (C#/Java estates have none). Ambiguous / external names are
-      // dropped (honest Group-A). Reuses the per-function call names the extractors parsed.
+      // function/class registry resolves first (exactly ONE in-repo definition — same
+      // unique-name discipline as the module-coarse calls) UNLESS the name is globally
+      // ambiguous but the CALLING module's own imports narrow it to one candidate (a
+      // same-named top-level helper the caller never imported must not block resolution
+      // of the one it did — e.g. two files each define `parseEntities`, only one is
+      // imported by a given caller; mirrors the same-module/imported-tiering already used
+      // for base-class resolution above, minus a same-module tier: two SIBLING top-level
+      // defines of one name, in the SAME module as the caller, stay ambiguous — see
+      // "ambiguous call names are dropped" in test/extract.test.mjs). On a complete
+      // registry miss, receiver-typed call texts fall through to the tiered METHOD
+      // registry above, so `_svc.ProcessOrder(...)` reaches `B.ProcessOrder` even though no
+      // top-level symbol carries that name (C#/Java estates have none). Still-ambiguous /
+      // external names are dropped (honest Group-A). Reuses the per-function call names
+      // the extractors parsed.
       if ((d.kind === "function" || d.kind === "method") && d.calls?.length) {
         for (const callName of d.calls) {
           const ident = lastIdent(callName);
           if (!ident) continue;
           const ids = nameToSymbolIds.get(ident);
           let callee = null;
-          if (ids?.size === 1) callee = [...ids][0];
-          else if (!ids) callee = resolveMethodCallee(callName, ident, m.path); // method fallback on a clean miss only
-          if (!callee) continue; // ambiguous or external → drop
+          if (ids?.size === 1) {
+            callee = [...ids][0];
+          } else if (ids?.size > 1) {
+            const reachable = [...ids].filter((id) => imports.has(id.slice(3, id.lastIndexOf("#"))));
+            if (reachable.length === 1) callee = reachable[0];
+          } else {
+            callee = resolveMethodCallee(callName, ident, m.path); // method fallback on a clean miss only
+          }
+          if (!callee) continue; // still ambiguous or external → drop
           if (callee === oid) continue; // self-recursion not an edge
           const ckey = `${oid}>${callee}`;
           if (seenCallSymbol.has(ckey)) continue;