@polycode-projects/seonix 0.9.1 → 0.10.0

package/src/interfaces.mjs

@@ -18,7 +18,9 @@ export function interfaceOpts(cfg = {}) {
     verbs: cfg.verbs && cfg.verbs.length ? cfg.verbs.map((s) => String(s).toLowerCase()) : VERBS,
     combineControllerPrefix: cfg.combineControllerPrefix !== false, // default true
     prefixStrip: (cfg.prefixStrip || []).map((s) => normPath(String(s))),
-    // Forward-compat: the confidence threshold the future callsHttp client↔route matcher will tune.
+    // Minimum matchScore (see below) for a callsHttp client↔route link. 1.0 = exact-length
+    // matches only; the 0.5 default also admits exact-prefix overlaps (e.g. a client URL with
+    // extra trailing segments over a shorter route template).
     matchThreshold: typeof cfg.matchThreshold === "number" ? cfg.matchThreshold : 0.5,
   };
 }
@@ -64,21 +66,28 @@ function parseCsAttr(attr) {
 }
 
 /** C# controller routes from a module's defines[] (Roslyn emits `[Http*]`/`[Route]` in decorators).
- *  Methods are named "Class.Method"; the class-level [Route] prefix is combined per opts. */
+ *  Methods are named "Class.Method". ASP.NET semantics honoured here:
+ *  - EVERY class-level `[Route("…")]` is a prefix (a controller can declare several — one route per
+ *    prefix × method mapping, document order, deterministic).
+ *  - A method-level verb attr with its own template (`[HttpGet("{id}")]`) uses that template.
+ *  - A verb attr with NO template (`[HttpPost]`) takes the method-level verb-less `[Route("…")]`
+ *    template(s) as its suffix — the common `[HttpPost] + [Route("process")]` pattern; with no
+ *    method [Route] either, the mapping is just the prefix. */
 function csRoutes(mod, opts) {
   const out = [];
   const defines = mod.defines || [];
-  // class name → { prefix, isController } from class-level [Route]/[ApiController]
+  // class name → { prefixes, isController } from class-level [Route]/[ApiController]
   const classInfo = new Map();
   for (const d of defines) {
     if (d.kind !== "class") continue;
-    let prefix = "", isController = /controller$/i.test(d.name);
+    const prefixes = [];
+    let isController = /controller$/i.test(d.name);
     for (const a of d.decorators || []) {
       const p = parseCsAttr(a);
-      if (p && p.verb === null && p.path) prefix = p.path;
+      if (p && p.verb === null && p.path) prefixes.push(p.path);
       if (/^apicontroller/i.test(String(a).trim())) isController = true;
     }
-    classInfo.set(d.name, { prefix, isController });
+    classInfo.set(d.name, { prefixes, isController });
   }
   for (const d of defines) {
     if (d.kind !== "method") continue;
@@ -87,14 +96,27 @@ function csRoutes(mod, opts) {
     const methodName = dot >= 0 ? d.name.slice(dot + 1) : d.name;
     const info = classInfo.get(className);
     const controller = className.replace(/Controller$/i, "");
+    // First pass over the method's attributes: verb mappings + verb-less [Route] templates.
+    const verbAttrs = [];
+    const routeTemplates = [];
     for (const a of d.decorators || []) {
       const p = parseCsAttr(a);
-      if (!p || p.verb === null) continue;               // only [Http*] maps a method to a verb
+      if (!p) continue;
+      if (p.verb === null) { if (p.path) routeTemplates.push(p.path); continue; }
       if (!opts.verbs.includes(p.verb)) continue;
-      const prefix = opts.combineControllerPrefix ? (info?.prefix || "") : "";
-      let path = subTokens(joinRoute(prefix, p.path), controller, methodName);
-      path = stripPrefixes(path, opts.prefixStrip);
-      out.push({ verb: p.verb.toUpperCase(), path, handler: d.name });
+      verbAttrs.push(p);
+    }
+    if (!verbAttrs.length) continue;                     // only [Http*] maps a method to a verb
+    const prefixes = opts.combineControllerPrefix && info?.prefixes.length ? info.prefixes : [""];
+    for (const p of verbAttrs) {
+      const suffixes = p.path ? [p.path] : (routeTemplates.length ? routeTemplates : [""]);
+      for (const prefix of prefixes) {
+        for (const suffix of suffixes) {
+          let path = subTokens(joinRoute(prefix, suffix), controller, methodName);
+          path = stripPrefixes(path, opts.prefixStrip);
+          out.push({ verb: p.verb.toUpperCase(), path, handler: d.name });
+        }
+      }
     }
   }
   return out;
@@ -124,16 +146,46 @@ function stripPrefixes(path, prefixes) {
 const isCs = (p) => /\.cs$/i.test(p || "");
 const isJsTs = (p) => /\.(m?[jt]sx?)$/i.test(p || "");
 
+/** Normalise a URL / route template into match segments (the deterministic half of callsHttp):
+ *  scheme+host stripped, query/hash dropped, duplicate slashes collapsed, and any parameter-ish
+ *  segment — `{id}` / `{id:int}` (ASP.NET, also a C# interpolation hole after quote-stripping),
+ *  `${expr}` / `{*}` (JS interpolation holes), `:id` (Express) — collapsed to a `*` wildcard.
+ *  Literal segments compare case-insensitively (ASP.NET routing is case-insensitive).
+ *  Exported for the matcher tests; pure. */
+export function normalizeHttpTemplate(url) {
+  let u = String(url || "").trim();
+  u = u.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]*/i, ""); // scheme://host[:port]
+  u = u.split(/[?#]/)[0];
+  u = normPath(u);
+  if (!u) return [];
+  return u.split("/").map((seg) => (/[{}]|^:/.test(seg) ? "*" : seg.toLowerCase()));
+}
+
+/** Deterministic template match: segment-by-segment prefix discipline (`*` matches any single
+ *  segment; the first literal mismatch is fatal), scored 2·shared/(|url|+|route|). 1.0 is an
+ *  exact-length match; an exact-prefix overlap scores below 1 and is admitted (or not) by the
+ *  match_threshold knob. No embeddings, no fuzzy scoring beyond this normalisation. */
+function matchScore(a, b) {
+  if (!a.length || !b.length) return 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i += 1) {
+    if (a[i] !== b[i] && a[i] !== "*" && b[i] !== "*") return 0;
+  }
+  return (2 * n) / (a.length + b.length);
+}
+
 /**
  * Build the `serves` edges + `Route` individuals for a set of modules.
  * @param modules  the same module records buildEntities consumes (path, defines[], routes[]).
  * @param fnId     the id-builder buildEntities uses: (path, symbolName) → "fn:path#name".
  * @param opts     from interfaceOpts().
- * @returns { edges, routes } — edges are {subject,object,subjectLabel,objectLabel}; routes are
- *          Route individuals. Both deterministically ordered; empty when nothing matched.
+ * @returns { edges, routes, callsHttp } — edges/callsHttp are {subject,object,subjectLabel,
+ *          objectLabel}; routes are Route individuals. All deterministically ordered; empty when
+ *          nothing matched.
  */
 export function extractServes(modules, { fnId, opts }) {
   const routeById = new Map();     // route id → individual (deduped across modules/methods)
+  const routeMeta = [];            // route id → {verb, segs} for the callsHttp matcher below
   const edgeSet = new Set();       // dedupe subject|object
   const edges = [];
   for (const mod of modules || []) {
@@ -143,7 +195,7 @@ export function extractServes(modules, { fnId, opts }) {
     for (const r of routes) {
       const label = `${r.verb} ${r.path}`;
       const rid = `route:${label}`;
-      if (!routeById.has(rid))
+      if (!routeById.has(rid)) {
         routeById.set(rid, {
           id: rid, label, class: "Route", derived_from: [], mentions: [],
           attributes: [
@@ -151,6 +203,8 @@ export function extractServes(modules, { fnId, opts }) {
             { prop: "mgx:routePath", key: "path", value: r.path },
           ],
         });
+        routeMeta.push({ id: rid, label, verb: r.verb, segs: normalizeHttpTemplate(r.path) });
+      }
       const object = fnId(mod.path, r.handler);
       const key = `${rid}|${object}`;
       if (edgeSet.has(key)) continue;
@@ -158,8 +212,47 @@ export function extractServes(modules, { fnId, opts }) {
       edges.push({ subject: rid, object, subjectLabel: label, objectLabel: r.handler });
     }
   }
-  edges.sort((a, b) => (a.subject < b.subject ? -1 : a.subject > b.subject ? 1 : a.object < b.object ? -1 : a.object > b.object ? 1 : 0));
+  const byEdge = (a, b) => (a.subject < b.subject ? -1 : a.subject > b.subject ? 1 : a.object < b.object ? -1 : a.object > b.object ? 1 : 0);
+  edges.sort(byEdge);
   const routes = [...routeById.values()].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+
+  // callsHttp (client→route) — the other half of the cross-service chain, PLAN_UNTYPED_INTERFACES
+  // follow-up #1. Client call sites come pre-captured from the extractors as an optional per-define
+  // `http_calls: [{verb, url}]` (fetch/axios/HttpClient first-argument URL literals). Each call is
+  // matched against the Route table just built: verbs must agree, templates match per matchScore
+  // above, and only the BEST-scoring route(s) at or above opts.matchThreshold link (ties all link —
+  // deterministic). A call matching nothing emits nothing; no orphan Route individuals are created,
+  // so callsHttp can only point at Routes that `serves` already justified.
+  const callsHttp = [];
+  const chSeen = new Set();
+  for (const mod of modules || []) {
+    for (const d of mod.defines || []) {
+      for (const c of d.http_calls || []) {
+        const verb = String(c.verb || "").toUpperCase();
+        const segs = normalizeHttpTemplate(c.url);
+        if (!segs.length) continue;
+        // No anchor, no edge: an all-wildcard template (`{base}{uri}/{id}`) would match ANY
+        // same-length route at 1.0 — at least one literal segment is required (house "no wrong edge").
+        if (!segs.some((s) => s !== "*")) continue;
+        let best = 0;
+        let hits = [];
+        for (const r of routeMeta) {
+          if (r.verb !== verb) continue;
+          const s = matchScore(segs, r.segs);
+          if (s < opts.matchThreshold || s < best) continue;
+          if (s > best) { best = s; hits = [r]; } else hits.push(r);
+        }
+        const subject = fnId(mod.path, d.name);
+        for (const r of hits) {
+          const key = `${subject}|${r.id}`;
+          if (chSeen.has(key)) continue;
+          chSeen.add(key);
+          callsHttp.push({ subject, object: r.id, subjectLabel: d.name, objectLabel: r.label });
+        }
+      }
+    }
+  }
+  callsHttp.sort(byEdge);
   // Vocabulary notes for the emitted tokens, built HERE (not in extract.mjs) so the un-typed-interface
   // props stay scoped to this gated feature module — the core schema drift guard documents the always
   // -on extract.mjs props; these opt-in props are self-documented inline until they earn a
@@ -167,5 +260,6 @@ export function extractServes(modules, { fnId, opts }) {
   const vocab = [];
   if (edges.length) vocab.push({ prop: "mgx:serves", predicate: "serves", note: "route-declaration→handler-symbol; the HTTP boundary a syntax-only AST misses (un-typed interface)" });
   if (routes.length) vocab.push({ prop: "mgx:httpVerb", note: "HTTP verb of a Route individual" }, { prop: "mgx:routePath", note: "normalised path template of a Route individual" });
-  return { edges, routes, vocab };
+  if (callsHttp.length) vocab.push({ prop: "mgx:callsHttp", predicate: "callsHttp", note: "client call-site→Route; HTTP URL literal matched to a route template (deterministic normalisation, match_threshold-gated)" });
+  return { edges, routes, vocab, callsHttp };
 }

package/src/jsts_tsc.mjs

@@ -66,6 +66,55 @@ function decoratorsOf(sf, node) {
   return (ds || []).map((d) => d.expression.getText(sf).replace(/\s+/g, " ").slice(0, 80));
 }
 
+// ---- HTTP-client call capture (un-typed interfaces: the callsHttp client→route half). ----
+// The URL literal at a client call site, per define — the base calls[] strips arguments, so the
+// route-matchable string must be captured here. Deterministic name gates, no resolution:
+//   fetch('/api/x' [, {method:'POST'}])         → verb from a literal `method:` property, else get
+//   <recv>.get|post|…('/api/x', …) where recv's text looks like an HTTP client (axios / http /
+//   client / api / request) — so Express-style registrations (router./app. receivers) and
+//   Map.get('key') never match.
+// The URL must be a string/template literal containing "/"; template interpolation holes become
+// `{*}` (collapsed to a wildcard segment by the matcher in interfaces.mjs). Emitted as an optional
+// `http_calls` field on the define — absent when empty, so modules without client calls are
+// byte-identical to before, and the DEFAULT graph ignores the field entirely (gating contract).
+const CLIENTISH = /axios|http|client|api|request/i;
+function urlLiteralText(sf, a) {
+  if (!a) return "";
+  if (ts.isStringLiteralLike(a)) return a.text; // 'x' / "x" / `x` (no holes)
+  if (ts.isTemplateExpression(a)) return a.head.text + a.templateSpans.map((s) => `{*}${s.literal.text}`).join("");
+  return "";
+}
+function httpCallsIn(sf, node) {
+  const out = [];
+  const seen = new Set();
+  const visit = (n) => {
+    if (ts.isCallExpression(n)) {
+      const t = n.expression;
+      let verb = "";
+      if ((ts.isIdentifier(t) && t.text === "fetch") || (ts.isPropertyAccessExpression(t) && t.name.text === "fetch")) {
+        verb = "get"; // fetch defaults to GET; a literal {method:'POST'} option overrides
+        const opt = n.arguments[1];
+        if (opt && ts.isObjectLiteralExpression(opt)) {
+          for (const p of opt.properties) {
+            if (ts.isPropertyAssignment(p) && p.name && p.name.getText(sf) === "method" && ts.isStringLiteralLike(p.initializer))
+              verb = p.initializer.text.toLowerCase();
+          }
+        }
+      } else if (ts.isPropertyAccessExpression(t) && ROUTE_VERBS.has(t.name.text.toLowerCase()) && CLIENTISH.test(t.expression.getText(sf))) {
+        verb = t.name.text.toLowerCase();
+      }
+      const url = verb ? urlLiteralText(sf, n.arguments[0]) : "";
+      if (ROUTE_VERBS.has(verb) && url.includes("/")) {
+        const key = `${verb} ${url}`;
+        if (!seen.has(key)) { seen.add(key); out.push({ verb, url: url.slice(0, 160) }); }
+      }
+    }
+    ts.forEachChild(n, visit);
+  };
+  ts.forEachChild(node, visit);
+  return out;
+}
+
 /** Collect callee names within a node body (coarse; unparsed call target). */
 function callsIn(sf, node) {
   const out = new Set();
@@ -129,12 +178,14 @@ export async function extractFile(absPath, root) {
   const isExportsRef = (e) => isModuleExports(e) || (ts.isIdentifier(e) && e.text === "exports");
 
   const addFn = (name, node, kind, extra = {}) => {
+    const http = httpCallsIn(sf, node);
     defines.push({
       name, kind, lineno: lineOf(sf, node), end_lineno: endLineOf(sf, node),
       decorators: decoratorsOf(sf, node),
       params: paramsText(sf, node), returns: returnText(sf, node),
       calls: callsIn(sf, node), doc: firstDocLine(sf, node),
       ...(visibilityOf(node) ? { visibility: visibilityOf(node) } : {}),
+      ...(http.length ? { http_calls: http } : {}),
       ...extra,
     });
   };

package/src/schema-docs.mjs

@@ -71,9 +71,11 @@ export const PREDICATE_DOCS = Object.freeze([
     "Module → Module. An import-backed, module-granular \"this file calls into that " +
     "file\" edge — not resolved to a specific symbol (see callsSymbol for that)." },
   { prop: "mgx:callsSymbol", kind: "callsSymbol", description:
-    "Function/Method → Function/Class. A call site resolved to exactly one same-named " +
-    "definition in the repository — unambiguous names only; an ambiguous or external " +
-    "call is dropped rather than guessed (no wrong edge)." },
+    "Function/Method → Function/Class/Method. A call site resolved to exactly one " +
+    "same-named definition in the repository — unambiguous names only (method targets " +
+    "resolve through a tiered simple-name fallback: same-module wins, interface members " +
+    "are excluded when one implementation remains); an ambiguous or external call is " +
+    "dropped rather than guessed (no wrong edge)." },
   { prop: "seon:declaresMethod", kind: "defines", description:
     "Module → Function/Class/Method/Attribute/GlobalVariable. What a module's top-level " +
     "scope actually declares." },
@@ -113,6 +115,23 @@ export const PREDICATE_DOCS = Object.freeze([
     "split) and any doc-comment prose, used by the second-pass prose-to-symbol " +
     "cross-reference index (PLAN_PROSE_INDEX.md) to resolve free-text object terms that " +
     "don't exact-match an identifier." },
+  // GATED (un-typed interfaces, PLAN_UNTYPED_INTERFACES.md; ROADMAP backlog #15): documented
+  // here so "what does serves mean" is answerable, but `gated: true` means ingestSchemaDocs
+  // only materialises the SchemaPredicate individual when the predicate is ACTUALLY present
+  // in this build's vocabulary — i.e. only on an interfaces-ON graph that found at least one
+  // route. A default/OFF graph never has "mgx:serves"/"mgx:callsHttp" in its vocabulary, so
+  // the guard keeps it out, preserving byte-identity (see the extended guard test in
+  // schema-docs.test.mjs).
+  { prop: "mgx:serves", kind: "serves", gated: true, description:
+    "Route → Function/Method. Route-declaration → handler-symbol — the HTTP boundary a " +
+    "syntax-only AST graph misses entirely (a route string is not a node, and a handler " +
+    "passed by reference at registration is not a call/import edge). Un-typed interfaces " +
+    "(PLAN_UNTYPED_INTERFACES.md), opt-in via SEONIX_INTERFACES=1 / [interfaces]." },
+  { prop: "mgx:callsHttp", kind: "callsHttp", gated: true, description:
+    "Function/Method → Route. Client call-site → Route, the fuzzy other half of the same " +
+    "un-typed-interface chain: an HTTP client call's URL literal (fetch/axios/HttpClient) " +
+    "matched to a Route's normalised path template (verb agreement, segment-wildcard " +
+    "matching, match_threshold-gated) — completes client → route → handler." },
 
   // ---- attributes (individual-scoped facts, not edges) ----
   { prop: "seon:startsAt", kind: "attribute", description:
@@ -240,6 +259,16 @@ export function ingestSchemaDocs(entities) {
     }
   }
 
+  // Present-predicate guard (ROADMAP backlog #15): a `gated: true` PREDICATE_DOCS entry (the
+  // un-typed-interfaces mgx:serves/mgx:callsHttp docs) only earns a SchemaPredicate individual
+  // when its prop is ACTUALLY present in this build's vocabulary — vocabulary entries for these
+  // props are themselves only emitted by interfaces.mjs when the gated feature is on AND found
+  // at least one match, so a default/OFF graph's vocabulary never contains them and this guard
+  // keeps their SchemaPredicate individuals out too, preserving byte-identity. Non-gated entries
+  // are unconditional, exactly as before.
+  const vocabProps = new Set((entities.vocabulary || []).map((v) => v?.prop));
+  const predicatePresent = (p) => !p.gated || vocabProps.has(p.prop);
+
   entities.individuals ||= [];
   const existingIds = new Set(entities.individuals.map((i) => i?.id));
   for (const c of CLASS_DOCS) {
@@ -247,6 +276,7 @@ export function ingestSchemaDocs(entities) {
     if (!existingIds.has(ind.id)) { entities.individuals.push(ind); existingIds.add(ind.id); }
   }
   for (const p of PREDICATE_DOCS) {
+    if (!predicatePresent(p)) continue;
     const ind = predicateIndividual(p);
     if (!existingIds.has(ind.id)) { entities.individuals.push(ind); existingIds.add(ind.id); }
   }

package/src/server.mjs

@@ -20,7 +20,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { loadConfig, ToolError } from "./config.mjs";
-import { createTelemetry } from "./telemetry.mjs";
+import { createTelemetry, truncateStr, looksLikeMiss } from "./telemetry.mjs";
 import * as defaultSource from "./source.mjs";
 import {
   parseEntities,
@@ -31,6 +31,7 @@ import {
   siteOf,
   renderMembers,
   renderSubclasses,
+  renderExternalSubclasses,
   renderArchitecture,
   renderTestsFor,
   renderUntested,
@@ -47,6 +48,7 @@ import {
   renderContextMore,
   renderCalls,
   callHint,
+  edgesOfKind,
   renderFileHistory,
   renderMethodHistory,
   renderClassHistory,
@@ -319,10 +321,24 @@ export async function dispatchTool(name, args, { config, source = defaultSource
     const graph = await loadGraph(config, source);
     const { match, candidates } = resolveOrThrow(graph, symbol, "symbol");
     const site = siteOf(match);
-    if (!site) {
+    // Path-vs-symbol UX (WH_ESTATE_AUDIT §2b): a Module match must never fall through to the
+    // span-slicer — some extractors stamp modules with a thin 1-2-line span, which used to
+    // render a near-empty, useless "snippet" for `seonix_snippet <file>`. Whether or not a
+    // span exists, answer with the actionable alternatives: the symbols the module defines
+    // (each snippet-able directly), seonix_describe, or reading the file itself.
+    if (String(match.class || "") === "Module" || !site) {
+      const defined = edgesOfKind(graph, "defines")
+        .filter((e) => e.subject === match.id)
+        .map((e) => e.objectLabel || e.object);
+      const cap = 12;
+      const list = defined.length
+        ? ` It defines: ${defined.slice(0, cap).join(", ")}${defined.length > cap ? `, +${defined.length - cap} more` : ""}.`
+        : "";
       throw new ToolError(
-        `"${match.label}" (${match.class || "Entity"}) has no source span in the graph — ` +
-          "it is likely a module. Use seonix_describe for its contents, then seonix_snippet one of the functions/classes it defines.",
+        `"${match.label}" is a ${match.class || "Module"} — seonix_snippet takes a symbol ` +
+          `(a function/class name or Class.Method), not a file path.${list}` +
+          ` seonix_snippet one of those, seonix_describe "${match.label}" for the module's full contents,` +
+          " or Read the file itself for raw source.",
       );
     }
     // repo root = the dir containing .seonix/ (graphFile = <repo>/.seonix/graph.json)
@@ -389,8 +405,23 @@ export async function dispatchTool(name, args, { config, source = defaultSource
     const symbol = String(args?.class || "").trim();
     if (!symbol) throw new ToolError("class is required");
     const graph = await loadGraph(config, source);
-    const { match } = resolveOrThrow(graph, symbol, "class");
-    return renderSubclasses(graph, match);
+    // Honest resolution (wh dogfood T14): exact match first; a fuzzy hit must never be
+    // presented as if it were the asked-for class.
+    const { match, candidates, exact } = resolveSymbol(graph, symbol);
+    if (exact) return renderSubclasses(graph, match);
+    // No individual with that exact name — an external/framework base may still appear
+    // as a supertype LABEL on inherits edges; if so, that's the real answer.
+    const external = renderExternalSubclasses(graph, symbol);
+    if (external) return external;
+    if (!match) {
+      throw new ToolError(
+        `no entity matching class "${symbol}" in the code-map graph. ` +
+          "Try a repo-relative path (e.g. django/utils/text.py), a basename, or seonix_search for a fuzzy lookup.",
+      );
+    }
+    // Fuzzy-only candidates: answer for the best match but NAME the substitution up front.
+    const others = candidates.length ? ` (other near matches: ${candidates.map((c) => c.label).join(", ")})` : "";
+    return `no exact match for "${symbol}"; nearest is "${match.label}"${others}:\n${renderSubclasses(graph, match)}`;
   }
   if (name === "seonix_architecture") {
     const graph = await loadGraph(config, source);
@@ -425,7 +456,16 @@ export async function dispatchTool(name, args, { config, source = defaultSource
           `${cands ? `: ${cands}` : ""}. Re-ask with a more specific query.`,
       );
     }
-    return `${content}\n\n---seonix_ask---\n${JSON.stringify(tmct_ask, null, 2)}`;
+    // Actionable caller-miss (wh dogfood C10/C11/T9): an empty symbol-level call answer used to
+    // name the traversal but not the cause or the next move. Port seonix_calls' honest wording:
+    // method-level call edges can be sparse for a language, so a miss is weak evidence — point
+    // at the module-level fallback instead of leaving the agent at a dead end.
+    const missNote = (tmct_ask?.miss === true && /callsSymbol/.test(String(tmct_ask?.traversal || "")))
+      ? "\nnote: method-level call edges (callsSymbol) can be sparse for this language — an empty answer " +
+        "is not proof of no callers. Fall back to module level: seonix_impact {\"module\":\"<file>\",\"depth\":1} " +
+        "for direct dependents, or ask \"which modules import <file>\"."
+      : "";
+    return `${content}${missNote}\n\n---seonix_ask---\n${JSON.stringify(tmct_ask, null, 2)}`;
   }
   if (
     name === "seonix_tests_for" || name === "seonix_history" || name === "seonix_callers" ||
@@ -486,8 +526,12 @@ export function buildServer({ config = loadConfig(), source = defaultSource, env
       const text = await dispatchTool(name, args || {}, { config, source });
       tel?.record({
         tool: name,
+        // wh dogfood backlog #6: telemetry recorded only tool+size — add the query/args text
+        // (truncated, correlation only), wall-clock duration, and a best-effort hit/miss flag.
+        query: { raw: truncateStr(JSON.stringify(args || {})) },
         response: { count: text ? text.split("\n").length : 0, truncated: /truncated/i.test(text) },
         perf: { ms_total: Date.now() - t0 },
+        quality: { miss: looksLikeMiss(text) },
         cost: { returned_chars: text.length, returned_tokens_est: Math.ceil(text.length / 4) },
       });
       return { content: [{ type: "text", text }] };

package/src/summary.mjs

@@ -92,6 +92,7 @@ export function hubModules(entities, { prefix = "", top = 5 } = {}) {
 export function buildSummary(entities, stats) {
   const {
     mode = "single", repos = [], skipped = [], languages = {}, graphBytes = 0,
+    store = "json", // "sqlite" ONLY when graph.db was actually built (SEONIX_STORE exported + write ok)
   } = stats || {};
 
   // per-class individual counts (the fix for the "7,345 = total?" misread)
@@ -133,9 +134,15 @@ export function buildSummary(entities, stats) {
   }
 
   // effective history depth for the run = the deepest pass across repos
-  const depths = repos.map((r) => r.historyDepth || { name: 0, symbol: 0 });
-  const nameDepth = depths.length ? Math.max(...depths.map((d) => d.name || 0)) : 0;
-  const symbolDepth = depths.length ? Math.max(...depths.map((d) => d.symbol || 0)) : 0;
+  // (running max, not Math.max(...spread) — one arg per repo, and spread-into-call is banned
+  // over anything repo-scaled; see test/edges-of-kind.test.mjs)
+  let nameDepth = 0;
+  let symbolDepth = 0;
+  for (const r of repos) {
+    const d = r.historyDepth || { name: 0, symbol: 0 };
+    if ((d.name || 0) > nameDepth) nameDepth = d.name || 0;
+    if ((d.symbol || 0) > symbolDepth) symbolDepth = d.symbol || 0;
+  }
 
   const repoRows = repos.map((r) => ({
     name: r.name,
@@ -156,6 +163,7 @@ export function buildSummary(entities, stats) {
       capChars: V8_STRING_CAP,
       capPct: `~${((graphBytes / V8_STRING_CAP) * 100).toFixed(1)}%`,
     },
+    store,
     history: { tier: historyTier(nameDepth), depth: { name: nameDepth, symbol: symbolDepth } },
     classes,
     edges: { total: edgeTotal, byPredicate },
@@ -174,6 +182,9 @@ export function renderSummaryMd(summary) {
   lines.push("# seonix index summary", "");
   lines.push(`- mode: ${summary.mode}`);
   lines.push(`- graph: ${fmt(summary.graph.bytes)} bytes (${summary.graph.capPct} of the V8 string cap)`);
+  // Store visibility: "sqlite" only when graph.db was actually built this run — a SEONIX_STORE
+  // that was set but never exported (invisible to child processes) reads `store: json` here.
+  lines.push(`- store: ${(summary.store || "json") === "sqlite" ? "sqlite (graph.db + graph.json; graph.json authoritative)" : "json (graph.json only)"}`);
   lines.push(`- history: tier=${summary.history.tier} depth name=${summary.history.depth.name} symbol=${summary.history.depth.symbol}`);
   const totalInds = Object.values(summary.classes).reduce((a, b) => a + b, 0);
   lines.push(`- individuals: ${fmt(totalInds)} total`);

package/src/telemetry.mjs

@@ -20,6 +20,37 @@ const DROP_KEYS = new Set(["text", "content", "snippet"]);
  *  question, which is the correlation key and is not file content). */
 const MAX_STR = 500;
 
+/** Truncate a string to ~`max` chars (default 200) for a query/args preview field —
+ *  the wh dogfood's "record the query/args text" ask, kept short deliberately (this is
+ *  a correlation aid, not the file-content-safe `query.raw` exemption in redact() below,
+ *  which some surfaces (locate/digest) still pass a short literal query through). Pure. */
+export function truncateStr(s, max = 200) {
+  const str = String(s ?? "");
+  return str.length > max ? str.slice(0, max) : str;
+}
+
+/** Best-effort, cheap-to-tell hit/miss classifier over a tool's RENDERED text output
+ *  (wh dogfood backlog #6: telemetry too thin to tell a query-mix's hit rate without
+ *  re-reading prose at analysis time). Matches the honest-miss phrasings the
+ *  codegraph.mjs renderers already use ("no entity matching", "none recorded", "cannot
+ *  map", "unknown kind/tool/argument", the tmct_ask envelope's own `"miss": true`) plus
+ *  the generic "no <kind> matches/found" shape. NOT exhaustive — a renderer can grow a
+ *  new miss phrasing this never learns — so `true` is fairly reliable, `false` only
+ *  means "no miss marker seen", not "definitely a hit". Pure. */
+const MISS_PATTERNS = [
+  /no entity matching/i,
+  /no [a-z]+ (matches|found)/i,
+  /:\s*no [a-z][a-z /-]* recorded\b/i,
+  /\bnone recorded\b/i,
+  /\bcannot map\b/i,
+  /^unknown (kind|tool|argument)/i,
+  /"miss"\s*:\s*true/,
+];
+export function looksLikeMiss(text) {
+  if (typeof text !== "string" || !text) return false;
+  return MISS_PATTERNS.some((re) => re.test(text));
+}
+
 /** Enabled iff `SEONIX_TELEMETRY==="1"` OR `[telemetry] enabled=true` in the toml.
  *  The env wins BOTH directions: `SEONIX_TELEMETRY==="0"` force-disables even when the
  *  toml turns it on. Default OFF (anything but "1"/"0" in the env falls through to toml). */