@polycode-projects/seonix 0.9.1 → 0.10.1

package/src/ask-browser.bundle.js

@@ -952,12 +952,62 @@
   );
   var MISSPELLING_RE = correctionRe(MISSPELLINGS);
   var WRONG_WORD_RE = correctionRe(WRONG_WORDS);
+  var RELATION_VERB_RE = new RegExp(
+    "\\b(?:" + Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b",
+    "i"
+  );
+  var INTERROGATIVE_LEAD_RE = /^(?:which|what|who|whose|where|when|why|how)\b/i;
+  var LISTING_TAIL_KINDS = /* @__PURE__ */ new Set([
+    "modules",
+    "files",
+    "functions",
+    "methods",
+    "classes",
+    "attributes",
+    "fields",
+    "properties",
+    "variables",
+    "globals",
+    "commits",
+    "changes",
+    "tests",
+    "members"
+  ]);
+  var BARE_KIND_RE = /^(?:all\s+|the\s+)?(?:module|file|function|method|class|attribute|field|property|variable|global|commit|change|test|member)\??$/i;
+  var isListingRemainder = (rest) => {
+    if (BARE_KIND_RE.test(rest)) return true;
+    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 MODAL_WRAPPER_RE = /^(?:can|could|would|will)\s+you\s+(?:please\s+)?(.+?)(?:[,\s]+please)?\??$/i;
+  var SHOW_GIVE_ME_RE = /^(?:show|give)\s+me\s+(?:the\s+)?(.+?)\??$/i;
+  function applyPreambleFrames(text) {
+    let q = String(text || "");
+    for (let pass = 0; pass < 3; pass++) {
+      const before = q;
+      let m = q.match(GREETING_PREAMBLE_RE);
+      if (m) q = m[1].trim();
+      m = q.match(MODAL_WRAPPER_RE);
+      if (m) q = m[1].trim();
+      m = q.match(SHOW_GIVE_ME_RE);
+      if (m) {
+        const rest = m[1].trim();
+        if (!isListingRemainder(rest)) {
+          q = RELATION_VERB_RE.test(rest) || INTERROGATIVE_LEAD_RE.test(rest) ? rest : `describe ${rest}`;
+        }
+      }
+      if (q === before) break;
+    }
+    return q;
+  }
   function normalizeQuery(text) {
     let q = String(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()]);
     q = q.replace(G_DROP, "$1ing");
+    q = applyPreambleFrames(q);
     if (FILLER_WORDS.length) {
       const fillerRe = new RegExp(
         "\\b(" + [...FILLER_WORDS].sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b",
@@ -1045,8 +1095,24 @@
     // separate authorship edge; "touched" IS the authorship signal (the churn commits
     // carry the author), so these are true synonyms of "who touched X", not a new
     // capability. Anaphora rides through untouched ("who wrote it" → "who touched it").
-    { re: /^who\s+(?:wrote|authored)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
-    { re: /^who\s+is\s+the\s+authors?\s+of\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
+    // SHA GUARD (0.8.2 feel wave): a COMMIT object is NOT a synonym — "who is the
+    // author of abc1234" rewritten to "who touched abc1234" dumps the commit's
+    // touch-SET instead of naming its author. The negative lookahead refuses the
+    // rewrite when the object is a bare (optionally "commit "-prefixed) 7-40 char
+    // hex sha, leaving the un-rewritten form for the author lane to consume;
+    // file/symbol objects (anything non-sha, e.g. "deadbeef.mjs") keep the rewrite.
+    { re: /^who\s+(?:wrote|authored)\s+(?:the\s+)?(?!(?:commit\s+)?[0-9a-f]{7,40}\??$)(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
+    { re: /^who\s+is\s+the\s+authors?\s+of\s+(?:the\s+)?(?!(?:commit\s+)?[0-9a-f]{7,40}\??$)(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
+    // HAS-TESTS → the coverage question the RELATIONS table answers. "does X have
+    // tests" parses "have" as a defines-verb (VERB_TO_KIND), producing the garbled
+    // "No — no defines edge found from X to <whatever resolves>" receipt; "is X
+    // tested" traverses tests edges from the WRONG side (subject = X). Both mean
+    // the coverage question "what tests X" — rewrite onto it. Closed to a
+    // tests/coverage object ("does X have methods/members" stays the members
+    // family) and refuses any "not" in the subject span, so the set-complement
+    // negations ("is X not tested") keep their own handler downstream.
+    { re: /^(?:does|do)\s+(?!.*\bnot\b)(.+?)\s+have\s+(?:any\s+)?(?:tests?|test\s+coverage|coverage)\??$/i, to: (m) => `what tests ${m[1]}` },
+    { re: /^(?:is|are)\s+(?!.*\bnot\b)(.+?)\s+tested\??$/i, to: (m) => `what tests ${m[1]}` },
     // NEEDS-TESTS → the untested-module survey. "what needs tests" / "what needs
     // testing" is the plainest way to ask which modules are uncovered, and it hit the
     // grammar wall ("no module matching 'needs'…"). Route it onto the same attributive
@@ -1864,7 +1930,9 @@
 
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/merge.mjs
   var DEFAULT_CONFIDENCE = 0.5;
-  var cmpTerm = (s) => String(s || "").trim().toLowerCase().replace(/\s+/g, " ").replace(/^commit\s+(?=[0-9a-f]{7,40}$)/, "");
+  var cmpTerm = (s) => String(s || "").trim().toLowerCase().replace(/\s+/g, " ").replace(/^(?:the|a|an)\s+/, "").replace(/^commit\s+(?=[0-9a-f]{7,40}$)/, "");
+  var LEADING_DET_RE = /^\s*(?:the|a|an)\s+/i;
+  var detCount = (p) => [p?.subject, p?.object].filter((t) => LEADING_DET_RE.test(String(t || ""))).length;
   function sameParse(p, q) {
     if (p.shape !== q.shape || p.kind !== q.kind) return false;
     if (p.shape === "ask") return cmpTerm(p.subject) === cmpTerm(q.subject) && cmpTerm(p.object) === cmpTerm(q.object);
@@ -1904,6 +1972,7 @@
         if (dup) {
           dup.agreed += 1;
           dup.confidence = Math.max(dup.confidence, c.confidence);
+          if (detCount(c.parsed) < detCount(dup.parsed)) dup.parsed = c.parsed;
           continue;
         }
         distinct.push({ ...c, agreed: 1 });
@@ -2049,11 +2118,15 @@
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/ask.mjs
   function edgesOfKind(graph, kind) {
     const out = [];
-    for (const g of graph.relations) if (relationKind(g) === kind) out.push(...g.edges);
+    for (const g of graph.relations) {
+      if (relationKind(g) !== kind) continue;
+      for (const e of g.edges) out.push(e);
+    }
     return out;
   }
   var SYMBOL_GRAIN_SIBLING = { calls: "callsSymbol", touches: "touchesSymbol" };
   var FINE_ENTITY_TYPES = /* @__PURE__ */ new Set(["Function", "Method", "Class", "Attribute", "GlobalVariable"]);
+  var FINE_CLASS_SIBLING = { Function: "Method", Method: "Function" };
   var KIND_UNIONS = { uses: ["imports", "calls", "callsSymbol"] };
   var kindsFor = (kind) => KIND_UNIONS[kind] || [kind];
   var OVERFLOW_CAP = 12;
@@ -2077,6 +2150,10 @@
   function verbFor(kind) {
     return REVERSE_MISS_VERB[kind] || kind;
   }
+  var LEADING_RELATION_VERB_RE = new RegExp(
+    `^(?:${Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})(?:s|ing|ed)?\\s+`,
+    "i"
+  );
   function defaultNlp() {
     return typeof nlpAdapter === "function" ? nlpAdapter() : null;
   }
@@ -2981,7 +3058,24 @@
         const token = (i.attributes || []).find((a) => a.key === "token")?.value;
         return token && String(token).toLowerCase() === termLc;
       });
-      if (!match) return { matches: [], objMatch: null, candidates: [], traversal: `schema lookup for "${term}"`, ambiguous: false };
+      if (!match) {
+        const classHits = (graph.individuals || []).filter((i) => i.class === "Class" && String(i.label).toLowerCase() === termLc);
+        if (classHits.length === 1) {
+          const hit2 = classHits[0];
+          const mid = moduleIdOf2(graph, hit2);
+          const modLabel = mid && graph.byId.get(mid)?.label || String((hit2.attributes || []).find((a) => a.key === "site")?.value || "").split(":")[0] || null;
+          return {
+            matches: [hit2],
+            objMatch: hit2,
+            candidates: [],
+            ambiguous: false,
+            metaCodeClass: true,
+            metaModuleLabel: modLabel,
+            traversal: `schema lookup for "${term}" (miss), then unique Class individual by label`
+          };
+        }
+        return { matches: [], objMatch: null, candidates: [], traversal: `schema lookup for "${term}"`, ambiguous: false };
+      }
       return {
         matches: [match],
         objMatch: match,
@@ -3090,9 +3184,13 @@
       return commitTouches(graph, objMatch, entityType, { candidates, ambiguous, matchedVia });
     }
     if (shape === "forward") {
-      const edges2 = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.subject === objMatch.id);
-      const matches2 = edges2.map((e) => graph.byId.get(e.object)).filter(Boolean);
-      return { matches: matches2, objMatch, candidates, traversal: `${kindsFor(kind).join("+")} edges where subject = ${objMatch.label}`, ambiguous, matchedVia };
+      const fwdSibling = SYMBOL_GRAIN_SIBLING[kind];
+      const subjIsFineSymbol = !!(fwdSibling && objMatch.class && FINE_ENTITY_TYPES.has(objMatch.class));
+      const fwdKinds = subjIsFineSymbol ? [.../* @__PURE__ */ new Set([...kindsFor(kind), fwdSibling])] : kindsFor(kind);
+      const edges2 = fwdKinds.flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.subject === objMatch.id);
+      const targets = edges2.map((e) => graph.byId.get(e.object)).filter(Boolean);
+      const matches2 = subjIsFineSymbol ? uniqueById(targets) : targets;
+      return { matches: matches2, objMatch, candidates, traversal: `${fwdKinds.join("+")} edges where subject = ${objMatch.label}`, ambiguous, matchedVia };
     }
     if (parsed.modifier === "transitive") {
       const levels = impactClosure(graph, objMatch, { maxDepth: TRANSITIVE_MAX_DEPTH });
@@ -3111,8 +3209,17 @@
     if (symbolKind && (FINE_ENTITY_TYPES.has(entityType) || objIsFineSymbol)) {
       const edges2 = edgesOfKind(graph, symbolKind).filter((e) => e.object === objMatch.id);
       const subjects2 = uniqueById(edges2.map((e) => graph.byId.get(e.subject)).filter(Boolean));
-      const matches2 = !entityType || entityType === "Change" ? subjects2 : subjects2.filter((i) => i.class === entityType);
-      return { matches: matches2, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}`, ambiguous, matchedVia };
+      let matches2 = !entityType || entityType === "Change" ? subjects2 : subjects2.filter((i) => i.class === entityType);
+      let widenNote = "";
+      const siblingClass = FINE_CLASS_SIBLING[entityType];
+      if (!matches2.length && siblingClass) {
+        const widened = subjects2.filter((i) => i.class === siblingClass);
+        if (widened.length) {
+          matches2 = widened;
+          widenNote = `, widened to ${siblingClass} subjects (no ${entityType} recorded)`;
+        }
+      }
+      return { matches: matches2, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}${widenNote}`, ambiguous, matchedVia };
     }
     let edges = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.object === objMatch.id);
     let extNote = "";
@@ -3214,6 +3321,16 @@
           ambiguous: false
         };
       }
+      if (result.metaCodeClass) {
+        const label = result.objMatch.label;
+        const definedIn = result.metaModuleLabel ? `, defined in ${result.metaModuleLabel}` : "";
+        return {
+          content: `${label} is a class in this codebase${definedIn} \u2014 try "describe ${label}" or "which classes inherit from ${label}".`,
+          miss: false,
+          ambiguous: false,
+          matches: result.matches
+        };
+      }
       const doc = (result.objMatch.attributes || []).find((a) => a.key === "doc")?.value || "";
       const kindWord = result.objMatch.class === "SchemaClass" ? "a class in the graph's schema" : "a predicate (relation) in the graph's schema";
       return { content: `${result.objMatch.label} is ${kindWord}: ${doc}`, miss: false, ambiguous: false, matches: result.matches };
@@ -3221,7 +3338,7 @@
     if (result.mentionsShape) {
       if (!result.matches.length) {
         return {
-          content: `"${parsed.object}" is not mentioned in any indexed identifier or doc-comment prose. (traversal: ${result.traversal})`,
+          content: `"${parsed.object}" is not mentioned in any indexed identifier or doc-comment prose.`,
           miss: true,
           ambiguous: false
         };
@@ -3278,7 +3395,7 @@
     if (result.whenShape) {
       const subject = result.objMatch.label;
       if (!result.matches.length) {
-        return { content: `no recorded commit touches ${subject} in this index. (traversal: ${result.traversal})`, miss: true, ambiguous: false };
+        return { content: `no recorded commit touches ${subject} in this index.`, miss: true, ambiguous: false };
       }
       const newest = result.matches[0];
       const date = (newest.attributes || []).find((a) => a.key === "date")?.value || "";
@@ -3306,7 +3423,7 @@
       const cite = `commit ${result.objMatch.label}`;
       if (!result.matches.length) {
         return {
-          content: `${cite} touched nothing recorded in the index. (traversal: ${result.traversal})`,
+          content: `${cite} touched nothing recorded in the index.`,
           miss: true,
           ambiguous: false
         };
@@ -3326,7 +3443,7 @@
         return { content: `couldn't resolve one of the terms in this question.`, miss: true, ambiguous: false };
       }
       return {
-        content: result.answer ? `Yes. (${result.traversal})` : `No \u2014 no ${parsed.kind} edge found from ${result.subjMatch.label} to ${result.objMatch.label}.`,
+        content: result.answer ? `Yes \u2014 ${result.traversal}.` : `No \u2014 no ${parsed.kind} edge found from ${result.subjMatch.label} to ${result.objMatch.label}.`,
         miss: !result.answer,
         ambiguous: false
       };
@@ -3334,22 +3451,23 @@
     if (!result.matches.length) {
       if (parsed.shape === "forward") {
         return {
-          content: `${result.objMatch.label} has no ${parsed.kind} edges in the index. (traversal: ${result.traversal || "no traversal resolved"})`,
+          content: `${result.objMatch.label} has no ${parsed.kind} edges in the index.`,
           miss: true,
           ambiguous: false
         };
       }
       if (parsed.kind === "tests" && !parsed.entityType) {
-        const obj = String(parsed.object || "").replace(/^cover(?:s|ing)?\s+/i, "").trim();
+        const stripped = String(parsed.object || "").replace(LEADING_RELATION_VERB_RE, "").trim();
+        const obj = stripped || String(parsed.object || "").trim();
         return {
-          content: `No tests cover ${obj}. (traversal: ${result.traversal || "no traversal resolved"})`,
+          content: `No tests cover ${obj}.`,
           miss: true,
           ambiguous: false
         };
       }
       const entityWord = nounFor(parsed.entityType || "Module", 2);
       return {
-        content: `No ${entityWord} found whose module directly ${verbFor(parsed.kind)} ${parsed.object}. (traversal: ${result.traversal || "no traversal resolved"})`,
+        content: `No ${entityWord} found whose module directly ${verbFor(parsed.kind)} ${parsed.object}.`,
         miss: true,
         ambiguous: false
       };

package/src/browser.mjs

@@ -46,6 +46,7 @@ const PROP_KIND = {
   "mgx:touchessymbol": "touchesSymbol",
   "mgx:callssymbol": "callsSymbol",
   "mgx:serves": "serves", // un-typed interfaces (gated); inert on a default graph
+  "mgx:callshttp": "callsHttp", // un-typed interfaces (gated); client call-site → Route
 };
 
 const pathOfId = (id) => {
@@ -284,7 +285,10 @@ export function buildTemporalGraph(raw, orderShas, { scope = "product", parentsB
   }
   const directBorn = (id) => {
     const s = touchesByNode.get(id);
-    return s && s.size ? Math.min(...s) : null;
+    if (!s || !s.size) return null;
+    let min = Infinity; // running min, not Math.min(...spread) — touch sets scale with history
+    for (const o of s) if (o < min) min = o;
+    return min;
   };
   const fallbackBorn = (id) => {
     let cur = parentOf.get(id);
@@ -604,7 +608,8 @@ function render(){
   const hs=(S.heat&&!cmp)?heatScale(S.tg,idx):null;
   const grav=S.grav?gravityAt(S.tg,hi):null;
   const gW=grav?new Map(grav.map(e=>[e.src+'|'+e.dst,e.w])):null;
-  const gMax=grav&&grav.length?Math.max(...grav.map(e=>e.w)):1;
+  let gMax=1; // running max, not Math.max(...spread) — gravity edge lists scale with the graph
+  if(grav&&grav.length){gMax=grav[0].w;for(const e of grav)if(e.w>gMax)gMax=e.w;}
   cy.batch(()=>{
     cy.nodes().forEach(cn=>{
       const n=S.byId.get(cn.id());
@@ -667,7 +672,8 @@ function runGravityLayout(){
   const hi=S.cursorB!=null?Math.max(S.cursor,S.cursorB):S.cursor;
   const g=gravityAt(S.tg,hi);
   const wByKey=new Map(g.map(e=>[e.src+'|'+e.dst,e.w]));
-  const maxW=g.length?Math.max(...g.map(e=>e.w)):1;
+  let maxW=1; // running max, not Math.max(...spread) — gravity edge lists scale with the graph
+  if(g.length){maxW=g[0].w;for(const e of g)if(e.w>maxW)maxW=e.w;}
   const wOf=e=>{const a=e.data('source'),b=e.data('target');return wByKey.get(a+'|'+b)??wByKey.get(b+'|'+a)??0;};
   const vis=S.cy.elements().filter(el=>el.style('display')==='element');
   vis.layout({name:'cose',animate:false,nodeRepulsion:6000,

package/src/codegraph.mjs

@@ -89,9 +89,10 @@ const PROP_KIND = {
   // closure (module-coarse) is unchanged.
   "mgx:touchessymbol": "touchesSymbol",
   "mgx:callssymbol": "callsSymbol",
-  // un-typed interfaces (PLAN_UNTYPED_INTERFACES.md) — route→handler; only present when the
-  // gated [interfaces] feature emitted serves edges, so this key is inert on a default graph.
+  // un-typed interfaces (PLAN_UNTYPED_INTERFACES.md) — route→handler + client→route; only present
+  // when the gated [interfaces] feature emitted edges, so these keys are inert on a default graph.
   "mgx:serves": "serves",
+  "mgx:callshttp": "callsHttp",
   // legacy tokens (pre-realign graphs) — kept so a stale artifact still classifies
   "seon:usescomplextype": "imports",
   "seon:invokesmethod": "calls",
@@ -189,6 +190,10 @@ export function resolveSymbol(graph, symbol) {
   return {
     match: scored[0]?.ind || null,
     candidates: scored.slice(1, 5).map((x) => x.ind),
+    // `exact` distinguishes a literal label/id hit from a path-normalised or substring
+    // (fuzzy) hit, so a caller can NAME a substitution instead of silently answering
+    // about a different symbol than the one asked for (wh dogfood T14).
+    exact: (scored[0]?.score ?? 0) === 100,
   };
 }
 
@@ -320,6 +325,36 @@ export function impactClosure(graph, ind, { maxDepth = 8 } = {}) {
         const subjLabel = graph.byId.get(subjModId)?.label || subjModId;
         addDependent(objModId, subjModId, subjLabel, g.predicate);
       }
+    } else if (kind === "serves") {
+      // Un-typed interfaces (interfaces.mjs, gated — these kinds never occur in a default
+      // graph, so the default closure is untouched). Edge direction as W4 emits it:
+      // subject = Route individual, object = handler symbol (fn:<path>#name). The Route
+      // and its handler are one interface point seen from two sides, so impact crosses
+      // the edge BOTH ways:
+      //  - reverse (like imports/calls): a handler change impacts its Route — keyed on
+      //    the handler symbol AND its module (coarsened on read, the callsSymbol
+      //    technique), so the closure crosses the edge whether it entered at symbol or
+      //    module level;
+      //  - forward: a Route change impacts its handler's module — so the closure from a
+      //    Route continues into the handler's own dependents at the next depth.
+      for (const e of g.edges) {
+        const handlerModId = moduleIdOfId(graph, e.object);
+        addDependent(e.object, e.subject, e.subjectLabel || e.subject, g.predicate);
+        if (handlerModId) {
+          addDependent(handlerModId, e.subject, e.subjectLabel || e.subject, g.predicate);
+          addDependent(e.subject, handlerModId, graph.byId.get(handlerModId)?.label || handlerModId, g.predicate);
+        }
+      }
+    } else if (kind === "callsHttp") {
+      // Gated, like serves. subject = client call-site symbol, object = Route individual.
+      // Reverse-only (a Route change impacts its HTTP clients; a client change never
+      // impacts the Route), caller coarsened to its module — completing the chain
+      // handler → Route (serves) → client modules (callsHttp).
+      for (const e of g.edges) {
+        const subjModId = moduleIdOfId(graph, e.subject);
+        if (!subjModId) continue;
+        addDependent(e.object, subjModId, graph.byId.get(subjModId)?.label || subjModId, g.predicate);
+      }
     } else if (kind === "tests") {
       for (const e of g.edges) {
         if (!coveredBy.has(e.object)) coveredBy.set(e.object, []);
@@ -689,9 +724,9 @@ function beamExpand(graph, scored, beamWidth) {
       }
       const [survivors, kindOverflow] = pruneToBeam(candidates);
       for (const [id, score] of survivors) merged.set(id, Math.max(merged.get(id) || 0, score));
-      plyOverflow.push(...kindOverflow);
+      plyOverflow.push(...kindOverflow); // spread OK: bounded by BEAM_OVERFLOW_CAP (≤4 args)
     }
-    overflow.push(...plyOverflow);
+    overflow.push(...plyOverflow); // spread OK: ≤ cap × edge groups = 16 args, never repo-scaled
     // Apply the bounded nudge once per module (first ply it's reached), same shape as the other
     // proximity families — a nudge, never a replacement.
     for (const [id, propagated] of merged) {
@@ -1292,21 +1327,20 @@ export function renderSignature(graph, ind) {
   return lines.join("\n");
 }
 
-/** Forward bases + the transitive reverse inheritance closure (who extends this) —
- *  replaces grepping `class X(Base)` across the tree. Uses `inherits` (mgx:subclassOf). */
-export function renderSubclasses(graph, ind) {
-  const inherits = edgesOfKind(graph, "inherits");
-  const bases = inherits.filter((e) => e.subject === ind.id).map((e) => e.objectLabel || e.object);
+/** child map over the `inherits` edges: base id → [{id,label}] of direct subclasses. */
+function inheritsChildrenOf(inherits) {
   const childrenOf = new Map();
   for (const e of inherits) {
     if (!childrenOf.has(e.object)) childrenOf.set(e.object, []);
     childrenOf.get(e.object).push({ id: e.subject, label: e.subjectLabel || e.subject });
   }
-  const lines = [`${ind.label} — ${ind.class || "Entity"} (id: ${ind.id})`];
-  lines.push(bases.length ? `extends: ${capJoin(bases, SUBCLASS_CAP)}` : "extends: (no internal/recorded base classes)");
-  const visited = new Set([ind.id]);
+  return childrenOf;
+}
+
+/** BFS the reverse-inheritance closure below `frontier` (depth-capped at 8); returns
+ *  sorted label levels. `visited` guards cycles and is mutated. */
+function descendSubclassLevels(childrenOf, frontier, visited) {
   const levels = [];
-  let frontier = [ind.id];
   for (let depth = 1; depth <= 8 && frontier.length; depth += 1) {
     const next = [];
     const level = [];
@@ -1324,6 +1358,18 @@ export function renderSubclasses(graph, ind) {
     }
     frontier = next;
   }
+  return levels;
+}
+
+/** Forward bases + the transitive reverse inheritance closure (who extends this) —
+ *  replaces grepping `class X(Base)` across the tree. Uses `inherits` (mgx:subclassOf). */
+export function renderSubclasses(graph, ind) {
+  const inherits = edgesOfKind(graph, "inherits");
+  const bases = inherits.filter((e) => e.subject === ind.id).map((e) => e.objectLabel || e.object);
+  const childrenOf = inheritsChildrenOf(inherits);
+  const lines = [`${ind.label} — ${ind.class || "Entity"} (id: ${ind.id})`];
+  lines.push(bases.length ? `extends: ${capJoin(bases, SUBCLASS_CAP)}` : "extends: (no internal/recorded base classes)");
+  const levels = descendSubclassLevels(childrenOf, [ind.id], new Set([ind.id]));
   const total = levels.reduce((n, l) => n + l.length, 0);
   if (!total) {
     lines.push("subclasses: none recorded — nothing extends it in the extracted graph.");
@@ -1334,6 +1380,44 @@ export function renderSubclasses(graph, ind) {
   return lines.join("\n");
 }
 
+/** Honest subclasses answer for a base-class NAME with no individual of its own — an
+ *  external/framework base (e.g. ASP.NET's ControllerBase) that appears only as a
+ *  supertype label on `inherits` edges. Lists the classes whose recorded supertype
+ *  label matches the name, plus their transitive subclasses. Returns null when no
+ *  inherits edge carries the label, so the caller can fall through. (wh dogfood T14:
+ *  the silent fuzzy substitution answered "none recorded" while 176 classes inherited
+ *  from the asked-for external base.) */
+export function renderExternalSubclasses(graph, name) {
+  const want = String(name || "").trim().toLowerCase();
+  if (!want) return null;
+  const inherits = edgesOfKind(graph, "inherits");
+  const matched = inherits.filter((e) => {
+    const label = String(e.objectLabel || "").trim().toLowerCase();
+    if (label) return label === want;
+    const id = String(e.object || "").toLowerCase();
+    return id === want || id.endsWith(`#${want}`); // label-less edge: match the id tail
+  });
+  if (!matched.length) return null;
+  const visited = new Set();
+  const direct = [];
+  for (const e of matched) {
+    if (visited.has(e.subject)) continue;
+    visited.add(e.subject);
+    direct.push({ id: e.subject, label: e.subjectLabel || e.subject });
+  }
+  const directLabels = direct.map((d) => d.label).sort((a, b) => String(a).localeCompare(String(b)));
+  const deeper = descendSubclassLevels(inheritsChildrenOf(inherits), direct.map((d) => d.id), visited);
+  const levels = [directLabels, ...deeper];
+  const total = levels.reduce((n, l) => n + l.length, 0);
+  const lines = [
+    `${name} — external/framework base class: not an individual in the graph, but ` +
+      `${matched.length} inherits edge(s) name it as a supertype.`,
+    `subclasses: ${total} total across ${levels.length} level(s).`,
+  ];
+  levels.forEach((l, i) => lines.push(`  depth ${i + 1} (${l.length}): ${capJoin(l, SUBCLASS_CAP)}`));
+  return lines.join("\n");
+}
+
 const ARCH_PKG_CAP = 25;
 const ARCH_HUB_CAP = 15;
 
@@ -1520,13 +1604,24 @@ export function renderClassHistory(graph, ind) {
   return renderSymbolHistory(graph, ind);
 }
 
-// ---- symbol search (kind=function/class/method/attribute, with name/decorator filters)
+// ---- symbol search (kind=function/class/method/attribute/route, with name/decorator filters)
 
-const SYMBOL_CLASSES = { function: "Function", class: "Class", method: "Method", attribute: "Attribute" };
+const SYMBOL_CLASSES = { function: "Function", class: "Class", method: "Method", attribute: "Attribute", route: "Route" };
+
+/** handler labels (with file:line where sited) a Route individual's `serves` edges point at —
+ *  a Route has no source span of its own, so the handler is what makes the line useful. */
+function routeHandlers(graph, servesEdges, routeId) {
+  return servesEdges
+    .filter((e) => e.subject === routeId)
+    .map((e) => {
+      const h = graph.byId.get(e.object);
+      return `${e.objectLabel || h?.label || e.object}${spanTag(h ? siteOf(h) : null)}`;
+    });
+}
 
 function searchSymbols(graph, tokens, { limit = SEARCH_LIMIT, kind, decFilter, nameRe }) {
   const targetClass = SYMBOL_CLASSES[kind];
-  if (!targetClass) return `unknown kind "${kind}" (use function, class, method, attribute, or module).`;
+  if (!targetClass) return `unknown kind "${kind}" (use function, class, method, attribute, route, or module).`;
   const hits = [];
   for (const ind of graph.individuals) {
     if ((ind.class || "") !== targetClass) continue;
@@ -1542,8 +1637,21 @@ function searchSymbols(graph, tokens, { limit = SEARCH_LIMIT, kind, decFilter, n
   hits.sort((a, b) => b.score - a.score || String(a.ind.label).length - String(b.ind.label).length);
   const top = hits.slice(0, limit);
   const lines = [`${hits.length} ${kind}(s) match (top ${top.length}):`];
-  for (const { ind } of top) lines.push(`- ${ind.label}${spanTag(siteOf(ind))}`);
-  lines.push("Then seonix_snippet <name> for the exact body, or seonix_describe for its edges.");
+  // Routes were dead data (wh dogfood C9/C18/T3/T11): 22 Route individuals + serves edges in the
+  // graph, reachable from no surface. A Route line shows verb + path template (its label) → the
+  // handler symbol(s) its serves edges point at, so the hit is actionable without another call.
+  const servesEdges = targetClass === "Route" ? edgesOfKind(graph, "serves") : null;
+  for (const { ind } of top) {
+    if (servesEdges) {
+      const handlers = routeHandlers(graph, servesEdges, ind.id);
+      lines.push(`- ${ind.label}${handlers.length ? ` → ${capJoin(handlers, 4)}` : " (no handler edge recorded)"}`);
+    } else {
+      lines.push(`- ${ind.label}${spanTag(siteOf(ind))}`);
+    }
+  }
+  lines.push(servesEdges
+    ? "Then seonix_snippet <Class.method> for a handler body, or seonix_describe for a route's edges."
+    : "Then seonix_snippet <name> for the exact body, or seonix_describe for its edges.");
   return lines.join("\n");
 }
 

package/src/cs_roslyn.mjs

@@ -3,15 +3,21 @@
 // prints the {modules:[…]} contract; this wrapper just shells out and parses it.
 // Falls back is the caller's job (cs_treesitter) when dotnet/the tool is absent.
 import { spawn } from "node:child_process";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { access } from "node:fs/promises";
+import { DLL as TOOL_DLL, ensureRoslynBuilt } from "./roslyn_build.mjs";
 
-const here = dirname(fileURLToPath(import.meta.url));
-const TOOL_DLL = join(here, "..", "roslyn", "publish", "roslyn-extract.dll");
+// Cached across calls within a process: chooseCs() in extract_lang.mjs calls
+// toolAvailable() once per ingestRepo() run, but tests and multi-repo indexing
+// can call it repeatedly — avoid re-spawning `dotnet --version` every time.
+// A fresh process (the normal case: one index run = one process) always
+// re-checks, so a dotnet toolchain installed after a prior failed attempt is
+// picked up automatically on the next run, no reinstall needed.
+let cachedAvailable;
 
+/** True if the Roslyn dll is present, lazily building it first (once per
+ *  process) when it's missing and `dotnet` is on PATH. */
 export async function toolAvailable() {
-  try { await access(TOOL_DLL); return true; } catch { return false; }
+  if (cachedAvailable === undefined) cachedAvailable = await ensureRoslynBuilt();
+  return cachedAvailable;
 }
 
 function run(cmd, args) {
@@ -26,7 +32,7 @@ function run(cmd, args) {
 }
 
 export async function ingest(root) {
-  if (!(await toolAvailable())) throw new Error("roslyn-extract.dll not built (run dotnet publish in roslyn/)");
+  if (!(await toolAvailable())) throw new Error("roslyn-extract.dll not available (no dotnet on PATH, or the lazy build failed — run `npm run build:roslyn` to retry with warnings)");
   const { code, out, err } = await run("dotnet", [TOOL_DLL, root]);
   if (code !== 0) throw new Error(`roslyn-extract failed (exit ${code}): ${err.slice(-300)}`);
   let parsed;