@polycode-projects/seonix 0.9.0 → 0.10.0

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_treesitter.mjs

@@ -54,6 +54,59 @@ function collectCalls(node) {
   return [...out].sort();
 }
 
+// ---- HTTP-client call capture (un-typed interfaces: the callsHttp client→route half). ----
+// `<recv>.GetAsync("api/x")`-style HttpClient invocations whose FIRST argument is a string
+// literal. The verb comes from the method name (Get|Post|Put|Delete|Patch, with the common
+// String/Stream/ByteArray/FromJson/AsJson suffixes, always ...Async); interpolated strings keep
+// their `{expr}` holes verbatim — the matcher in interfaces.mjs collapses them to wildcard
+// segments. The URL must contain "/". Emitted as an optional `http_calls` field on the method
+// define — absent when empty, and the DEFAULT graph ignores the field (gating contract).
+// NOTE: the tree-sitter backend only; the Roslyn backend does not capture http_calls yet.
+const HTTP_METHOD = /^(get|post|put|delete|patch)(string|stream|bytearray|fromjson|asjson)?async$/;
+const URL_LITERALS = new Set(["string_literal", "verbatim_string_literal", "interpolated_string_expression", "raw_string_literal"]);
+function collectHttpCalls(node) {
+  const out = [];
+  const seen = new Set();
+  const visit = (n) => {
+    if (n.type === "invocation_expression") {
+      const fn = n.childForFieldName("function");
+      const name = fn && fn.type === "member_access_expression" ? (fn.childForFieldName("name")?.text || "") : "";
+      const m = HTTP_METHOD.exec(name.toLowerCase());
+      if (m) {
+        const arg = n.childForFieldName("arguments")?.namedChild(0); // first `argument` node
+        const expr = arg?.namedChild(0) || arg;
+        if (expr && URL_LITERALS.has(expr.type)) {
+          const url = expr.text.replace(/\s+/g, " ").replace(/^[$@]+/, "").replace(/^"+|"+$/g, "").slice(0, 160);
+          if (url.includes("/")) {
+            const key = `${m[1]} ${url}`;
+            if (!seen.has(key)) { seen.add(key); out.push({ verb: m[1], url }); }
+          }
+        }
+      }
+    }
+    for (let i = 0; i < n.namedChildCount; i++) visit(n.namedChild(i)); // document order
+  };
+  visit(node);
+  return out;
+}
+
+/** C# attributes on a declaration node → decorator strings, matching the Roslyn
+ *  backend's shape (`m.AttributeLists.SelectMany(a => a.Attributes)` + OneLine):
+ *  each `attribute` child of an `attribute_list`, whitespace-collapsed to one line.
+ *  So `[Route("api/[controller]")]` → `Route("api/[controller]")` on both backends. */
+function attrsOf(node) {
+  const out = [];
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const list = node.namedChild(i);
+    if (list.type !== "attribute_list") continue;
+    for (let j = 0; j < list.namedChildCount; j++) {
+      const a = list.namedChild(j);
+      if (a.type === "attribute") out.push(a.text.replace(/\s+/g, " ").trim());
+    }
+  }
+  return out;
+}
+
 function modifiersText(node) {
   // tree-sitter-c-sharp surfaces modifiers as anonymous children before the name
   const mods = [];
@@ -76,7 +129,7 @@ function emitType(n, prefix, defines, exports) {
   const bases = [];
   const baseList = n.childForFieldName("bases") || n.namedChildren.find((c) => c.type === "base_list");
   if (baseList) for (let i = 0; i < baseList.namedChildCount; i++) bases.push(baseList.namedChild(i).text.slice(0, 80));
-  defines.push({ name: cname, kind: "class", lineno: line(n), end_lineno: endLine(n), bases, decorators: [],
+  defines.push({ name: cname, kind: "class", lineno: line(n), end_lineno: endLine(n), bases, decorators: attrsOf(n),
     ...(SUBKIND[n.type] ? { subkind: SUBKIND[n.type] } : {}),
     ...(visFrom(mods) ? { visibility: visFrom(mods) } : {}) });
   if (mods.includes("public")) exports.add(cname);
@@ -94,10 +147,12 @@ function emitType(n, prefix, defines, exports) {
       const mmods = modifiersText(mem);
       const params = (mem.childForFieldName("parameters")?.text || "").replace(/\s+/g, " ").replace(/^\(|\)$/g, "").slice(0, 160);
       const returns = (mem.childForFieldName("returns") || mem.childForFieldName("type"))?.text?.slice(0, 80) || "";
+      const http = collectHttpCalls(mem);
       defines.push({ name: `${cname}.${mn}`, kind: "method", lineno: line(mem), end_lineno: endLine(mem),
-        decorators: [], params, returns, calls: collectCalls(mem),
+        decorators: attrsOf(mem), params, returns, calls: collectCalls(mem),
         ...(mmods.includes("static") ? { is_static: true } : {}),
-        ...(visFrom(mmods) ? { visibility: visFrom(mmods) } : {}) });
+        ...(visFrom(mmods) ? { visibility: visFrom(mmods) } : {}),
+        ...(http.length ? { http_calls: http } : {}) });
     } else if (mem.type === "property_declaration") {
       const mn = fieldText(mem, "name");
       if (mn) defines.push({ name: `${cname}.${mn}`, kind: "attribute", lineno: line(mem), end_lineno: endLine(mem), decorators: [] });

package/src/extract.mjs

@@ -13,7 +13,9 @@
 //   mgx:testsCoverage       Module → Module   (a test module → the internal modules it imports)
 //   seon:history            Commit → Module   (from git log --name-only)
 //   mgx:touchesSymbol       Commit → CodeEntity (commit changed-line-range ∩ symbol span)
-//   mgx:callsSymbol         Function/Method → Function/Class (symbol-granular, unambiguous)
+//   mgx:callsSymbol         Function/Method → Function/Class/Method (symbol-granular,
+//                                              unambiguous; method targets resolve through a
+//                                              tiered simple-name fallback — see buildEntities)
 //   seon:containsCodeEntity Class  → Method/Attribute (class membership)
 //   mgx:subclassOf          Class  → Class    (inheritance; internal base resolved, else ext:)
 
@@ -233,9 +235,38 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
   // Registry of top-level functions/classes by simple name — used to resolve coarse
   // call targets AND inheritance bases to a single internal module (else dropped).
   const classToPaths = new Map();    // class name -> Set<path> (for base resolution)
+  // Method-level call-target registries. Receiver-typed call texts (`_svc.ProcessOrder(...)`,
+  // `self.render()`) never match a top-level function/class name, and on C#/Java estates there
+  // are NO top-level functions at all — so without these every method stays caller-less.
+  const methodToSymbolIds = new Map();       // simple method name (last ident of the define) -> Set<fnId>
+  const dottedMethodToSymbolIds = new Map(); // "Owner.Method" (last two idents of the define) -> Set<fnId>
+  const interfaceOwnedIds = new Set();       // method ids owned by a class defined with subkind "interface"
   for (const m of modules) {
+    // Interface class names in THIS module first (defines are document-ordered, but a full
+    // pre-pass keeps membership independent of class/member ordering).
+    const interfaceNames = new Set();
     for (const d of m.defines || []) {
-      if (d.kind === "method" || d.kind === "attribute" || d.kind === "global") continue; // not standalone call targets
+      if (d.kind === "class" && d.subkind === "interface") interfaceNames.add(d.name);
+    }
+    for (const d of m.defines || []) {
+      if (d.kind === "method") {
+        const id = fnId(m.path, d.name);
+        const simple = lastIdent(d.name);
+        if (simple) {
+          if (!methodToSymbolIds.has(simple)) methodToSymbolIds.set(simple, new Set());
+          methodToSymbolIds.get(simple).add(id);
+        }
+        const parts = d.name.split(".");
+        if (parts.length >= 2) {
+          const dotted = parts.slice(-2).join(".");
+          if (!dottedMethodToSymbolIds.has(dotted)) dottedMethodToSymbolIds.set(dotted, new Set());
+          dottedMethodToSymbolIds.get(dotted).add(id);
+        }
+        const owner = d.name.includes(".") ? d.name.slice(0, d.name.lastIndexOf(".")) : "";
+        if (owner && interfaceNames.has(owner)) interfaceOwnedIds.add(id);
+        continue;
+      }
+      if (d.kind === "attribute" || d.kind === "global") continue; // not standalone call targets
       const register = (name) => {
         if (!nameToPaths.has(name)) nameToPaths.set(name, new Set());
         nameToPaths.get(name).add(m.path);
@@ -267,6 +298,32 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
     return ids[0];
   };
 
+  // Resolve a receiver-typed call text (`_svc.ProcessOrder`, `self.render`) to ONE method
+  // define, tiered and deterministic — same honest Group-A discipline as the base registry,
+  // mirroring its same-module-wins rule:
+  //   0. precision: the call's last TWO identifiers hit the dotted "Owner.Method" registry
+  //      uniquely (qualified/static call texts) → it;
+  //   a. exactly one candidate defined in the calling module → local win;
+  //   b. else exactly one after excluding interface-owned members → the implementation
+  //      wins over the interface declaration it satisfies;
+  //   c. else exactly one overall → it;
+  //   d. else drop (ambiguous → no edge, never guessed).
+  const resolveMethodCallee = (callName, ident, path) => {
+    const dm = String(callName).match(/([A-Za-z_][A-Za-z0-9_]*)\s*\.\s*([A-Za-z_][A-Za-z0-9_]*)\s*$/);
+    if (dm) {
+      const dotted = dottedMethodToSymbolIds.get(`${dm[1]}.${dm[2]}`);
+      if (dotted?.size === 1) return [...dotted][0];
+    }
+    const cands = methodToSymbolIds.get(ident);
+    if (!cands || !cands.size) return null;
+    const pre = `fn:${path}#`;
+    const local = [...cands].filter((i) => i.startsWith(pre));
+    if (local.length === 1) return local[0];
+    const impls = [...cands].filter((i) => !interfaceOwnedIds.has(i));
+    if (impls.length === 1) return impls[0];
+    return cands.size === 1 ? [...cands][0] : null;
+  };
+
   // resolve a module's import candidates to internal module paths
   const internalImports = (m) => {
     const set = new Set();
@@ -380,17 +437,22 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
         }
       }
 
-      // symbol-granular calls: caller fn/method → callee fn/class, resolved ONLY when the
-      // callee simple name has exactly ONE in-repo definition (same unique-name discipline
-      // as the module-coarse calls). Ambiguous / receiver-typed / external names are dropped
-      // (honest Group-A). Reuses the per-function call names already parsed by extract_ast.py.
+      // 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.
       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);
-          if (!ids || ids.size !== 1) continue; // ambiguous or external → drop
-          const callee = [...ids][0];
+          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 (callee === oid) continue; // self-recursion not an edge
           const ckey = `${oid}>${callee}`;
           if (seenCallSymbol.has(ckey)) continue;
@@ -544,7 +606,7 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
   // a no-op → byte-identical graph.json/summary.json (the measurement contract).
   const serves = interfaces?.enabled
     ? extractServes(modules, { fnId, opts: interfaceOpts(interfaces) })
-    : { edges: [], routes: [], vocab: [] };
+    : { edges: [], routes: [], vocab: [], callsHttp: [] };
 
   // Second pass (PLAN_PROSE_INDEX.md) — see the returned `proseIndex` field's comment below.
   const allIndividuals = attachProseTokens(
@@ -564,7 +626,7 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
     vocabulary: [
       { prop: "mgx:importsNamespace", predicate: "imports", note: "module→module; SEON usesComplexType is type→type, so owned (cf. main:dependsOn)" },
       { prop: "mgx:callsCoarse", predicate: "calls", note: "module→module, import-backed; NOT SEON's method→method invokesMethod" },
-      { prop: "mgx:callsSymbol", predicate: "callsSymbol", note: "caller fn/method→callee fn/class; symbol-granular, unique-name-resolved (Group A); cf. seon:invokesMethod" },
+      { prop: "mgx:callsSymbol", predicate: "callsSymbol", note: "caller fn/method→callee fn/class/method; symbol-granular, unique-name-resolved (Group A; method targets via a tiered simple-name fallback — same-module wins, interface members excluded when one implementation remains); cf. seon:invokesMethod" },
       { prop: "seon:declaresMethod", predicate: "defines" },
       { prop: "seon:containsCodeEntity", predicate: "contains" },
       { prop: "mgx:touchedByCommit", predicate: "touches", note: "owned; seon:history is not a real SEON property (cf. history:isCommittedIn)" },
@@ -617,8 +679,10 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
       rel("cochange", "mgx:changeCoupledWith", cochangeEdges),
       rel("reexports", "mgx:reExports", reExportEdges),
       // GATED (PLAN_UNTYPED_INTERFACES.md): emitted ONLY when the interfaces feature produced
-      // edges, so the default graph never carries a zero-count `serves` group → byte-identical.
+      // edges, so the default graph never carries a zero-count `serves`/`callsHttp` group →
+      // byte-identical.
       ...(serves.edges.length ? [rel("serves", "mgx:serves", serves.edges)] : []),
+      ...(serves.callsHttp.length ? [rel("callsHttp", "mgx:callsHttp", serves.callsHttp)] : []),
     ],
     individuals: allIndividuals,
     // Second pass (PLAN_PROSE_INDEX.md): word -> [individual ids], inverted from the
@@ -828,6 +892,10 @@ async function assembleAndWrite(rootDir, { modules, commits, symbolHistory, gene
   // the same in-memory payload, stamped with the JSON's stat for freshness. Mirrors the
   // SEONIX_PROSE_INDEX env-gate precedent; unset → no import of node:sqlite, no graph.db,
   // byte-identical default path. Best-effort: graph.json stays authoritative on any failure.
+  // storeMode feeds the A1 summary's `store:` line — "sqlite" ONLY when graph.db was actually
+  // (re)built, so an inactive gate (e.g. SEONIX_STORE set in the shell but never EXPORTED) is
+  // visible at a glance instead of silently running the JSON single-string path.
+  let storeMode = "json";
   if (process.env.SEONIX_STORE === "sqlite") {
     try {
       const { writeStore, storeFileFor } = await import("./store.mjs");
@@ -837,6 +905,7 @@ async function assembleAndWrite(rootDir, { modules, commits, symbolHistory, gene
       // file, so verifyStore/readPayload-freshness would fail on every fresh v2 store. Mirrors
       // bin/cli.mjs store_rebuild (which passes sourceText: text).
       await writeStore(storeFileFor(graphFile), entities, { sourceStat, sourceText: payload });
+      storeMode = "sqlite";
     } catch (e) {
       process.stderr.write(`seonix: sqlite store build failed (${e?.message || e}) — graph.json is authoritative\n`);
     }
@@ -848,7 +917,7 @@ async function assembleAndWrite(rootDir, { modules, commits, symbolHistory, gene
     ? codegraph.renderToolsCatalog(CLI_SCRIPT)
     : localToolsCatalog(CLI_SCRIPT);
   await writeFile(join(rootDir, ".seonix", "TOOLS.md"), toolsMd);
-  return { entities, graphFile, graphBytes };
+  return { entities, graphFile, graphBytes, storeMode };
 }
 
 function buildCounts(entities, { modules, languages, commits, proseEnabled, baseMs, historyMs }) {
@@ -886,7 +955,7 @@ export async function indexRepository(repoPath, { python = DEFAULT_PYTHON(), gen
   const { modules, perLang, commits, symbolHistory, baseMs, historyMs, gitErrors } = r;
   warnGitErrors(gitErrors, repoPath); // surface any history-pass failure immediately (never fatal)
   const sessions = await readSessionRecords(repoPath); // recorded chat sessions (.seonix/sessions/*.jsonl), [] when none
-  const { entities, graphFile, graphBytes } = await assembleAndWrite(repoPath, { modules, commits, symbolHistory, generatedAt, proseEnabled, sessions, interfaces });
+  const { entities, graphFile, graphBytes, storeMode } = await assembleAndWrite(repoPath, { modules, commits, symbolHistory, generatedAt, proseEnabled, sessions, interfaces });
   // A1 post-index summary: SUMMARY.md + summary.json next to graph.json (NEW files; the
   // graph.json bytes are untouched). The rendered MD is also printed to stdout by cli.mjs.
   const summary = buildSummary(entities, {
@@ -901,6 +970,7 @@ export async function indexRepository(repoPath, { python = DEFAULT_PYTHON(), gen
     skipped: [],
     languages: perLang,
     graphBytes,
+    store: storeMode,
   });
   await writeSummaryArtifacts(dirname(graphFile), summary);
   return {
@@ -961,7 +1031,8 @@ export function applyRepoPrefix({ modules, commits, symbolHistory }, prefix) {
 export function defaultOutRoot(repoPaths, cwd = process.cwd()) {
   const segs = repoPaths.map((p) => resolve(p).split(sep));
   const first = segs[0];
-  let depth = Math.min(...segs.map((s) => s.length));
+  let depth = first.length; // running min, not Math.min(...spread) — one arg per repo path
+  for (const s of segs) if (s.length < depth) depth = s.length;
   let i = 0;
   while (i < depth && segs.every((s) => s[i] === first[i])) i += 1;
   const ancestor = first.slice(0, i).join(sep) || sep;
@@ -1018,9 +1089,11 @@ export async function indexRepositories(repoPaths, { python = DEFAULT_PYTHON(),
     const r = await extractRepo(rp, { python, ignores, historyDepth, extraIgnores, languages: languageAllow });
     warnGitErrors(r.gitErrors, prefix); // surface any history-pass failure immediately (never fatal)
     applyRepoPrefix(r, prefix);
-    allModules.push(...r.modules);
-    allCommits.push(...r.commits);
-    allSymbolHistory.push(...r.symbolHistory);
+    // NB: append iteratively — spreading into push() passes one argument per element and
+    // module/commit lists scale with repo size, past V8's argument-count limit on estates.
+    for (const m of r.modules) allModules.push(m);
+    for (const c of r.commits) allCommits.push(c);
+    for (const h of r.symbolHistory) allSymbolHistory.push(h);
     baseMs += r.baseMs;
     historyMs += r.historyMs;
     for (const [lang, s] of Object.entries(r.perLang)) {
@@ -1036,7 +1109,7 @@ export async function indexRepositories(repoPaths, { python = DEFAULT_PYTHON(),
   // TODO(sessions): multi-repo merges don't fold in the member repos' .seonix/sessions
   // yet — their recorded ids would need the same repo-name prefixing as modules to
   // re-resolve against the merged graph. Deferred; single-path fold-in is the contract.
-  const { entities, graphFile, graphBytes } = await assembleAndWrite(root, {
+  const { entities, graphFile, graphBytes, storeMode } = await assembleAndWrite(root, {
     modules: allModules, commits: allCommits, symbolHistory: allSymbolHistory, generatedAt, proseEnabled, interfaces,
   });
   // A1 post-index summary (merged): per-repo rows (name = prefix) + any discovery
@@ -1053,6 +1126,7 @@ export async function indexRepositories(repoPaths, { python = DEFAULT_PYTHON(),
     skipped,
     languages,
     graphBytes,
+    store: storeMode,
   });
   await writeSummaryArtifacts(dirname(graphFile), summary);
   return {
@@ -1188,9 +1262,10 @@ export async function syncRepositories(multiRoot, { python = DEFAULT_PYTHON(), g
     } else {
       ext = await readCache(artifactDir, name); // reused post-prefix extraction
     }
-    allModules.push(...ext.modules);
-    allCommits.push(...ext.commits);
-    allSymbolHistory.push(...ext.symbolHistory);
+    // NB: append iteratively — same repo-scaled-spread hazard as indexRepositories above.
+    for (const m of ext.modules) allModules.push(m);
+    for (const c of ext.commits) allCommits.push(c);
+    for (const h of ext.symbolHistory) allSymbolHistory.push(h);
     for (const [lang, s] of Object.entries(ext.perLang || {})) {
       const agg = languages[lang] || (languages[lang] = { lib: s.lib, files: 0, modules: 0, symbols: 0, failures: 0, ms: 0 });
       agg.files += s.files; agg.modules += s.modules; agg.symbols += s.symbols; agg.failures += s.failures; agg.ms += s.ms;
@@ -1208,10 +1283,10 @@ export async function syncRepositories(multiRoot, { python = DEFAULT_PYTHON(), g
   for (const r of diff.removed) await rm(cachePath(artifactDir, r.name), { force: true }).catch(() => {});
 
   // ONE buildEntities over the union (cached + fresh) → the exact full-re-index graph.
-  const { entities, graphFile, graphBytes } = await assembleAndWrite(root, {
+  const { entities, graphFile, graphBytes, storeMode } = await assembleAndWrite(root, {
     modules: allModules, commits: allCommits, symbolHistory: allSymbolHistory, generatedAt, proseEnabled, interfaces,
   });
-  const summary = buildSummary(entities, { mode: "multi", repos: repoRows, skipped: [], languages, graphBytes });
+  const summary = buildSummary(entities, { mode: "multi", repos: repoRows, skipped: [], languages, graphBytes, store: storeMode });
   await writeSummaryArtifacts(dirname(graphFile), summary);
   await writeManifest(artifactDir, { format: 1, generated_at: generatedAt, repos: manifestRows });
 

package/src/extract_lang.mjs

@@ -66,9 +66,11 @@ export async function ingestRepo(root, { cs, java, ignore = null } = {}) {
     const { modules, failures, fileCount } = await extractor.ingest(root, { ignore });
     const ms = Date.now() - t0;
     if (fileCount === 0) continue; // language not present
-    allModules.push(...modules);
+    // NB: append iteratively — spreading into push() passes one argument per module and
+    // per-language module counts hit ~20k+ on estates, past V8's argument-count limit.
+    for (const m of modules) allModules.push(m);
     totalFiles += fileCount;
-    allFailures.push(...failures);
+    for (const f of failures) allFailures.push(f);
     const symbols = modules.reduce((n, m) => n + (m.defines?.length || 0), 0);
     perLang[lang] = { lib: extractor.meta.lib, files: fileCount, modules: modules.length, symbols, failures: failures.length, ms };
   }