@polycode-projects/the-mechanical-code-talker 0.3.0 → 0.5.0

package/src/prose-nlp.mjs

@@ -1,23 +1,23 @@
 // prose-nlp.mjs — the OPTIONAL wink-nlp lemma loader behind prose.mjs's LEMMA layer.
 //
-// Deliberately a SEPARATE loader from ask-nlp.mjs (same createRequire pattern, same
-// deps) rather than an import of it: ask-nlp.mjs belongs to the ask-engine surface
-// and is under active concurrent work — the prose pre-pass must not couple its
-// index-build path to that file's export shape. The ~20 duplicated lines are the
-// decoupling fee; the wink model itself is loaded lazily and at most once per
-// process either way.
+// Kept SEPARATE from ask-nlp.mjs (its own `proseLemma` export shape) rather than an
+// import of that ask-engine surface — but both now share the neutral leaf loader
+// src/wink-model.mjs, so the wink model is resolved in ONE place. The former ~20
+// duplicated createRequire lines are gone; the coupling this file avoids is to
+// ask-nlp.mjs's export shape, not to a leaf model loader.
 //
-// BOUNDARY (same as ask-nlp.mjs, hard): Node-only, never inlined into the viewer
-// bundle. prose.mjs is itself never inlined by viz.mjs's askSource(), so nothing
-// browser-side can reach this module. wink-nlp + wink-eng-lite-web-model are CJS —
-// loaded via createRequire, lazily, with failure cached as null: a checkout without
-// the optional deps simply builds no lemma layer (honestly absent), it never throws.
+// BOUNDARY (same as ask-nlp.mjs, hard): Node-only path, never inlined into the
+// viewer bundle. prose.mjs is itself never inlined by viz.mjs's askSource(), so
+// nothing browser-side can reach this module. The wink pair is loaded lazily (Node
+// createRequire fallback, or the browser registration seam), failure cached as null:
+// a checkout without the optional deps simply builds no lemma layer (honestly
+// absent), it never throws.
 //
 // Determinism: wink's lemmatiser is a fixed trained model with no sampling — the
 // same token always yields the same lemma across runs and processes, which is what
 // lets the lemma layer meet the "byte-identical proseIndex across builds" contract.
 
-import { createRequire } from "node:module";
+import { winkInstance } from "./wink-model.mjs";
 
 let cached; // undefined = not tried yet; null = unavailable (tried once, honestly off)
 
@@ -27,10 +27,8 @@ let cached; // undefined = not tried yet; null = unavailable (tried once, honest
 export function proseLemma() {
   if (cached !== undefined) return cached;
   try {
-    const require = createRequire(import.meta.url);
-    const winkNLP = require("wink-nlp");
-    const model = require("wink-eng-lite-web-model");
-    const nlp = winkNLP(model);
+    const nlp = winkInstance();
+    if (!nlp) { cached = null; return cached; }
     const its = nlp.its;
     const memo = new Map();
     cached = (word) => {

package/src/providers/bootstrap.mjs

@@ -0,0 +1,24 @@
+// The BOOTSTRAP reference provider — the empty/degenerate graph a fresh repo
+// "contains" before anything is indexed. PLAN_REPOSITORY_INTERFACE.md deliverable
+// 2: "bootstrap returns honest empties".
+//
+// It implements every Repository-Interface service over the empty bootstrap
+// payload (src/source.mjs emptyEntities): every id-taking service returns
+// miss(UNRESOLVED_TERM) — there are no individuals — and every aggregate returns
+// an honest empty (stats.total = 0, untested.modules = [], …). Nothing throws.
+// This is the other end of the compatibility kit: the provider that has no data
+// must still CONFORM.
+
+import { parseEntities } from "../codegraph.mjs";
+import { emptyEntities } from "../source.mjs";
+import { createGraphService } from "./graph-service.mjs";
+
+/** The parsed empty bootstrap graph. */
+export function bootstrapGraph() {
+  return parseEntities(emptyEntities());
+}
+
+/** The bootstrap provider: every service over the empty graph — honest empties. */
+export function bootstrapProvider() {
+  return createGraphService(bootstrapGraph());
+}

package/src/providers/fixture.mjs

@@ -0,0 +1,118 @@
+// The FIXTURE reference provider — a small, real, self-contained code graph that
+// implements every Repository-Interface service. PLAN_REPOSITORY_INTERFACE.md
+// deliverable 2: "the executable specification an external producer reads first".
+//
+// It is a degenerate provider in the sense that its graph is tiny and its source
+// bodies are absent (snippet/context answer NO_SOURCE) — but every OTHER service
+// returns real graph truth. The contract suite (test/repository-interface.test.mjs)
+// runs the whole compatibility kit against it.
+//
+// The payload is embedded (not read from test/) so this ships as a runnable spec
+// inside the library. Its shape is exactly a parseEntities() input.
+
+import { parseEntities } from "../codegraph.mjs";
+import { createGraphService } from "./graph-service.mjs";
+
+/** A compact but type-complete entities payload: modules, a class hierarchy
+ *  (Base ← Widget ← Button), a method with a full signature, an attribute, a
+ *  module global, and a commit — wired by one edge of every closed kind. */
+export const FIXTURE_ENTITIES = Object.freeze({
+  generated_at: "2026-07-05T00:00:00.000Z",
+  bootstrap: false,
+  prefixes: { seon: "http://se-on.org/ontologies/seon.owl#", mgx: "urn:tmct:mgx#" },
+  classes: [
+    { name: "Module", count: 5, sample: ["pkg/core/graph.mjs"] },
+    { name: "Class", count: 3, sample: ["Base", "Widget", "Button"] },
+    { name: "Method", count: 1, sample: ["Widget.render"] },
+    { name: "Attribute", count: 1, sample: ["Widget.name"] },
+    { name: "Function", count: 1, sample: ["parseNode"] },
+    { name: "Commit", count: 1, sample: ["a1b2c3d"] },
+  ],
+  vocabulary: [],
+  objectProperties: [
+    { predicate: "imports", prop: "mgx:importsNamespace", count: 3, examples: [
+      { subject: "mod:view.mjs", object: "mod:graph.mjs", subjectLabel: "pkg/ui/view.mjs", objectLabel: "pkg/core/graph.mjs" },
+      { subject: "mod:widget.mjs", object: "mod:graph.mjs", subjectLabel: "pkg/ui/widget.mjs", objectLabel: "pkg/core/graph.mjs" },
+      { subject: "mod:button.mjs", object: "mod:widget.mjs", subjectLabel: "pkg/ui/button.mjs", objectLabel: "pkg/ui/widget.mjs" },
+    ] },
+    { predicate: "calls", prop: "mgx:callsCoarse", count: 1, examples: [
+      { subject: "mod:script.mjs", object: "mod:graph.mjs", subjectLabel: "scripts/build.mjs", objectLabel: "pkg/core/graph.mjs" },
+    ] },
+    { predicate: "callsSymbol", prop: "mgx:callsSymbol", count: 1, examples: [
+      { subject: "m:render", object: "fn:parseNode", subjectLabel: "Widget.render", objectLabel: "parseNode" },
+    ] },
+    { predicate: "defines", prop: "seon:declaresMethod", count: 3, examples: [
+      { subject: "mod:graph.mjs", object: "fn:parseNode", subjectLabel: "pkg/core/graph.mjs", objectLabel: "parseNode" },
+      { subject: "mod:widget.mjs", object: "cls:widget", subjectLabel: "pkg/ui/widget.mjs", objectLabel: "Widget" },
+      { subject: "mod:widget.mjs", object: "g:register", subjectLabel: "pkg/ui/widget.mjs", objectLabel: "register" },
+    ] },
+    { predicate: "tests", prop: "mgx:testsCoverage", count: 1, examples: [
+      { subject: "mod:widget.test.mjs", object: "mod:widget.mjs", subjectLabel: "pkg/test/widget.test.mjs", objectLabel: "pkg/ui/widget.mjs" },
+    ] },
+    { predicate: "touches", prop: "mgx:touchedByCommit", count: 1, examples: [
+      { subject: "commit:a1b2c3d", object: "mod:widget.mjs", subjectLabel: "a1b2c3d", objectLabel: "pkg/ui/widget.mjs" },
+    ] },
+    { predicate: "touchesSymbol", prop: "mgx:touchesSymbol", count: 1, examples: [
+      { subject: "commit:a1b2c3d", object: "m:render", subjectLabel: "a1b2c3d", objectLabel: "Widget.render" },
+    ] },
+    { predicate: "contains", prop: "seon:containsCodeEntity", count: 2, examples: [
+      { subject: "cls:widget", object: "m:render", subjectLabel: "Widget", objectLabel: "render" },
+      { subject: "cls:widget", object: "a:name", subjectLabel: "Widget", objectLabel: "name" },
+    ] },
+    { predicate: "inherits", prop: "seon:hasSuperType", count: 2, examples: [
+      { subject: "cls:widget", object: "cls:base", subjectLabel: "Widget", objectLabel: "Base" },
+      { subject: "cls:button", object: "cls:widget", subjectLabel: "Button", objectLabel: "Widget" },
+    ] },
+    { predicate: "cochange", prop: "mgx:changeCoupledWith", count: 1, examples: [
+      { subject: "mod:widget.mjs", object: "mod:graph.mjs", subjectLabel: "pkg/ui/widget.mjs", objectLabel: "pkg/core/graph.mjs", weight: 3 },
+    ] },
+    { predicate: "reexports", prop: "mgx:reExports", count: 1, examples: [
+      { subject: "mod:widget.mjs", object: "cls:widget", subjectLabel: "pkg/ui/widget.mjs", objectLabel: "Widget" },
+    ] },
+  ],
+  individuals: [
+    { id: "mod:graph.mjs", label: "pkg/core/graph.mjs", class: "Module", derived_from: ["git:a1b2c3d"], mentions: [] },
+    { id: "mod:view.mjs", label: "pkg/ui/view.mjs", class: "Module", derived_from: [], mentions: [] },
+    { id: "mod:widget.mjs", label: "pkg/ui/widget.mjs", class: "Module", derived_from: ["git:a1b2c3d"], mentions: [] },
+    { id: "mod:button.mjs", label: "pkg/ui/button.mjs", class: "Module", derived_from: [], mentions: [] },
+    { id: "mod:script.mjs", label: "scripts/build.mjs", class: "Module", derived_from: [], mentions: [] },
+    { id: "mod:widget.test.mjs", label: "pkg/test/widget.test.mjs", class: "Module", derived_from: [], mentions: [] },
+    { id: "fn:parseNode", label: "parseNode", class: "Function", derived_from: [], mentions: [], attributes: [
+      { prop: "seon:startsAt", key: "site", value: "pkg/core/graph.mjs:10-24" },
+      { prop: "seon:hasParameter", key: "params", value: "node, depth=0" },
+      { prop: "seon:hasReturnType", key: "returns", value: "Node" },
+    ] },
+    { id: "cls:base", label: "Base", class: "Class", derived_from: [], mentions: [], attributes: [{ prop: "seon:startsAt", key: "site", value: "pkg/core/graph.mjs:1-6" }] },
+    { id: "cls:widget", label: "Widget", class: "Class", derived_from: [], mentions: [], attributes: [{ prop: "seon:startsAt", key: "site", value: "pkg/ui/widget.mjs:1-40" }] },
+    { id: "cls:button", label: "Button", class: "Class", derived_from: [], mentions: [], attributes: [{ prop: "seon:startsAt", key: "site", value: "pkg/ui/button.mjs:1-12" }] },
+    { id: "m:render", label: "Widget.render", class: "Method", derived_from: [], mentions: [], attributes: [
+      { prop: "seon:startsAt", key: "site", value: "pkg/ui/widget.mjs:8-20" },
+      { prop: "mgx:decorator", key: "decorators", value: "property" },
+      { prop: "seon:hasParameter", key: "params", value: "self, mode='full'" },
+      { prop: "seon:hasReturnType", key: "returns", value: "str" },
+      { prop: "seon:throwsException", key: "raises", value: "ValueError" },
+      { prop: "seon:accessesField", key: "self_fields", value: "name, size" },
+      { prop: "seon:hasDoc", key: "doc", value: "Render the widget." },
+    ] },
+    { id: "a:name", label: "Widget.name", class: "Attribute", derived_from: [], mentions: [], attributes: [{ prop: "seon:startsAt", key: "site", value: "pkg/ui/widget.mjs:2" }] },
+    { id: "g:register", label: "register", class: "GlobalVariable", derived_from: [], mentions: [], attributes: [
+      { prop: "seon:startsAt", key: "site", value: "pkg/ui/widget.mjs:1" },
+      { prop: "mgx:value", key: "value", value: "Library()" },
+    ] },
+    { id: "commit:a1b2c3d", label: "a1b2c3d", class: "Commit", derived_from: [], mentions: [], attributes: [
+      { prop: "mgx:commitAuthor", key: "author", value: "Grace Hopper" },
+      { prop: "mgx:commitDate", key: "date", value: "2026-07-01" },
+      { prop: "mgx:commitMessage", key: "message", value: "render the widget in full mode" },
+    ] },
+  ],
+});
+
+/** The parsed fixture graph (shared, immutable truth). */
+export function fixtureGraph() {
+  return parseEntities(FIXTURE_ENTITIES);
+}
+
+/** The fixture provider: a Repository-Interface service over the small real graph. */
+export function fixtureProvider() {
+  return createGraphService(fixtureGraph());
+}

package/src/providers/graph-service.mjs

@@ -0,0 +1,312 @@
+// The reference Repository-Interface service over a parsed code graph.
+// PLAN_REPOSITORY_INTERFACE.md — "the executable specification".
+//
+// createGraphService(graph) returns a typed service object implementing EVERY
+// service in src/repository-interface.mjs over the `{ individuals, byId,
+// relations, … }` shape parseEntities() yields. Every method returns a typed
+// Result (hit/miss) — a clean miss is a value, never a throw. The two providers
+// tmct ships (fixture, bootstrap) are this same builder over a small real graph
+// and over the empty bootstrap graph respectively.
+//
+// This is a GRAPH-ONLY provider: it advertises the source services (snippet,
+// context) but answers them with an honest miss(NO_SOURCE) — it exposes no
+// working tree. A host with a working tree (seonix, the chat shell) layers source
+// access on top. Pure graph queries, no fs, no LLM.
+
+import {
+  resolveSymbol,
+  siteOf,
+  edgesOfKind,
+  relationKind,
+  impactClosure,
+} from "../codegraph.mjs";
+import { ask } from "../ask.mjs";
+import {
+  hit,
+  miss,
+  toIndividual,
+  toEdge,
+  MISS_REASONS,
+  EDGE_KINDS,
+  SERVICES,
+  SOURCE_SERVICES,
+  INTERFACE_VERSION,
+} from "../repository-interface.mjs";
+
+const attrOf = (ind, key) => (ind?.attributes || []).find((a) => a.key === key)?.value ?? null;
+
+/** Group an individual id's incoming/outgoing edges across all relations, projected
+ *  to interface Edges. */
+function edgesAround(graph, id) {
+  const out = [];
+  const incoming = [];
+  for (const g of graph.relations) {
+    for (const e of g.edges) {
+      if (e.subject === id) out.push(toEdge(e, { predicate: g.predicate, prop: g.prop }));
+      if (e.object === id) incoming.push(toEdge(e, { predicate: g.predicate, prop: g.prop }));
+    }
+  }
+  return { out, incoming };
+}
+
+/** The kind-tagged relation group's predicate/prop for a given edge kind (for Edge
+ *  projection). Returns the first relation group classifying to `kind`. */
+function groupMetaForKind(graph, kind) {
+  for (const g of graph.relations) if (relationKind(g) === kind) return { predicate: g.predicate, prop: g.prop };
+  return { predicate: kind, prop: null };
+}
+
+/**
+ * @param {object} graph  a parseEntities() result
+ * @param {object} [opts]
+ * @param {boolean} [opts.sourceAccess=false]  whether source services can read bodies
+ * @returns the typed service object
+ */
+export function createGraphService(graph, { sourceAccess = false } = {}) {
+  const byId = graph.byId;
+
+  const resolveId = (id) => byId.get(id) || null;
+
+  const svc = {
+    version: INTERFACE_VERSION,
+    /** Advertised services. Source services are listed but honestly answer NO_SOURCE
+     *  unless a source-capable provider overrides them. */
+    capabilities: [...SERVICES],
+    sourceAccess: Boolean(sourceAccess),
+    /** The underlying graph — tmct-internal presentation (render*) reads it; not
+     *  part of the wire contract. */
+    graph,
+
+    resolve(term) {
+      const { match, candidates } = resolveSymbol(graph, String(term ?? ""));
+      if (!match) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: String(term ?? "") });
+      return hit({ match: toIndividual(match), candidates: candidates.map(toIndividual) });
+    },
+
+    describe(id) {
+      const ind = resolveId(id);
+      if (!ind) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: id });
+      const { out, incoming } = edgesAround(graph, id);
+      return hit({ individual: toIndividual(ind), out, incoming });
+    },
+
+    members(classId) {
+      const ind = resolveId(classId);
+      if (!ind) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: classId });
+      const contains = edgesOfKind(graph, "contains").filter((e) => e.subject === classId);
+      const methods = [];
+      const attributes = [];
+      for (const e of contains) {
+        const m = byId.get(e.object);
+        const proj = m ? toIndividual(m) : { id: e.object, label: e.objectLabel || e.object, class: "Entity", attributes: [] };
+        if ((m?.class || "") === "Attribute") attributes.push(proj);
+        else methods.push(proj);
+      }
+      return hit({ methods, attributes });
+    },
+
+    subclasses(classId) {
+      const ind = resolveId(classId);
+      if (!ind) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: classId });
+      const inherits = edgesOfKind(graph, "inherits");
+      const bases = inherits
+        .filter((e) => e.subject === classId)
+        .map((e) => byId.get(e.object) ? toIndividual(byId.get(e.object)) : { id: e.object, label: e.objectLabel || e.object, class: "Class", attributes: [] });
+      // transitive reverse inheritance closure (who extends this)
+      const childrenOf = new Map();
+      for (const e of inherits) {
+        if (!childrenOf.has(e.object)) childrenOf.set(e.object, []);
+        childrenOf.get(e.object).push(e.subject);
+      }
+      const seen = new Set([classId]);
+      const subs = [];
+      let frontier = [classId];
+      for (let d = 0; d < 8 && frontier.length; d += 1) {
+        const next = [];
+        for (const cur of frontier) {
+          for (const childId of childrenOf.get(cur) || []) {
+            if (seen.has(childId)) continue;
+            seen.add(childId);
+            const c = byId.get(childId);
+            subs.push(c ? toIndividual(c) : { id: childId, label: childId, class: "Class", attributes: [] });
+            next.push(childId);
+          }
+        }
+        frontier = next;
+      }
+      return hit({ bases, subclasses: subs });
+    },
+
+    exports(moduleId) {
+      const ind = resolveId(moduleId);
+      if (!ind) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: moduleId });
+      const edges = edgesOfKind(graph, "reexports").filter((e) => e.subject === moduleId);
+      const exports = edges.map((e) =>
+        byId.get(e.object) ? toIndividual(byId.get(e.object)) : { id: e.object, label: e.objectLabel || e.object, class: "Entity", attributes: [] });
+      return hit({ exports });
+    },
+
+    signature(id) {
+      const ind = resolveId(id);
+      if (!ind) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: id });
+      const flags = [];
+      for (const [attr, name] of [["isStatic", "static"], ["isAbstract", "abstract"], ["isConstant", "constant"]]) {
+        if (attrOf(ind, attr)) flags.push(name);
+      }
+      const vis = attrOf(ind, "visibility");
+      if (vis) flags.push(vis);
+      return hit({
+        id: ind.id,
+        label: ind.label,
+        class: ind.class || "Entity",
+        params: attrOf(ind, "params"),
+        returns: attrOf(ind, "returns"),
+        raises: attrOf(ind, "raises"),
+        decorators: attrOf(ind, "decorators"),
+        doc: attrOf(ind, "doc"),
+        selfFields: attrOf(ind, "self_fields"),
+        flags,
+      });
+    },
+
+    edges(id, kind) {
+      if (!EDGE_KINDS.includes(kind)) {
+        throw new TypeError(`edges(): unknown kind "${kind}" (not in EDGE_KINDS)`);
+      }
+      const ind = resolveId(id);
+      if (!ind) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: id });
+      const meta = groupMetaForKind(graph, kind);
+      const edges = edgesOfKind(graph, kind)
+        .filter((e) => e.subject === id)
+        .map((e) => toEdge(e, meta));
+      return hit({ kind, edges });
+    },
+
+    impact(moduleId) {
+      const ind = resolveId(moduleId);
+      if (!ind) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: moduleId });
+      const levels = impactClosure(graph, ind);
+      const total = levels.reduce((n, l) => n + l.length, 0);
+      return hit({ total, levels });
+    },
+
+    snippet(id) {
+      const ind = resolveId(id);
+      if (!ind) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: id });
+      const site = siteOf(ind);
+      if (!svc.sourceAccess) {
+        return miss(MISS_REASONS.NO_SOURCE, {
+          term: id,
+          detail: site ? `span is ${site.path}:${site.start}-${site.end}; this provider exposes no working tree` : "no source span in the graph",
+        });
+      }
+      if (!site) return miss(MISS_REASONS.NO_SOURCE, { term: id, detail: "no source span in the graph (likely a module)" });
+      // A source-capable subclass overrides snippet to read the body; the graph-only
+      // base returns the span with a null body.
+      return hit({ path: site.path, span: { start: site.start, end: site.end }, body: null });
+    },
+
+    context(symbol) {
+      const { match } = resolveSymbol(graph, String(symbol ?? ""));
+      if (!match) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: String(symbol ?? "") });
+      return miss(MISS_REASONS.NO_SOURCE, {
+        term: String(symbol ?? ""),
+        detail: "the edit bundle reaches into the working tree; this provider exposes no source",
+      });
+    },
+
+    architecture({ package: pkg = "" } = {}) {
+      const norm = String(pkg || "").trim().toLowerCase().replace(/^\.?\//, "");
+      const modules = graph.individuals.filter(
+        (i) => (i.class || "") === "Module" && (!norm || String(i.label || "").toLowerCase().startsWith(norm)),
+      );
+      const pkgCount = new Map();
+      for (const m of modules) {
+        const dir = m.label.includes("/") ? m.label.slice(0, m.label.lastIndexOf("/")) : "(root)";
+        pkgCount.set(dir, (pkgCount.get(dir) || 0) + 1);
+      }
+      const modSet = new Set(modules.map((m) => m.id));
+      const inDeg = new Map();
+      for (const e of edgesOfKind(graph, "imports")) {
+        if (modSet.has(e.object)) inDeg.set(e.object, (inDeg.get(e.object) || 0) + 1);
+      }
+      const hubs = [...inDeg.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .map(([id, n]) => ({ id, label: byId.get(id)?.label || id, importers: n }));
+      const packages = [...pkgCount.entries()].sort((a, b) => b[1] - a[1]);
+      return hit({ modules: modules.length, packages, hubs });
+    },
+
+    untested() {
+      const covered = new Set(edgesOfKind(graph, "tests").map((e) => e.object));
+      const modules = graph.individuals
+        .filter((i) => (i.class || "") === "Module" && !covered.has(i.id) && !/\.test\./.test(i.label || ""))
+        .map(toIndividual);
+      return hit({ modules });
+    },
+
+    stats() {
+      const counts = new Map();
+      for (const i of graph.individuals) {
+        const c = i.class || "Entity";
+        counts.set(c, (counts.get(c) || 0) + 1);
+      }
+      const classes = [...counts.entries()]
+        .map(([cls, count]) => ({ class: cls, count }))
+        .sort((a, b) => b.count - a.count || a.class.localeCompare(b.class));
+      return hit({ total: graph.individuals.length, classes, truncated: (graph.truncated || []).length > 0 });
+    },
+
+    history(id) {
+      const ind = resolveId(id);
+      if (!ind) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: id });
+      const touchEdges = [
+        ...edgesOfKind(graph, "touches"),
+        ...edgesOfKind(graph, "touchesSymbol"),
+      ].filter((e) => e.object === id);
+      const seen = new Set();
+      const commits = [];
+      for (const e of touchEdges) {
+        if (seen.has(e.subject)) continue;
+        seen.add(e.subject);
+        const c = byId.get(e.subject);
+        commits.push({
+          id: e.subject,
+          label: e.subjectLabel || c?.label || e.subject,
+          author: c ? attrOf(c, "author") ?? attrOf(c, "commitAuthor") : null,
+          date: c ? attrOf(c, "date") ?? attrOf(c, "commitDate") : null,
+          message: c ? attrOf(c, "message") ?? attrOf(c, "commitMessage") : null,
+        });
+      }
+      return hit({ commits });
+    },
+
+    search(query, { kind = "", name = "", decorator = "" } = {}) {
+      const q = String(query || "").trim().toLowerCase();
+      const k = String(kind || "").trim().toLowerCase();
+      const nm = String(name || "").trim().toLowerCase();
+      const dec = String(decorator || "").trim().toLowerCase();
+      const results = graph.individuals
+        .filter((i) => {
+          const label = String(i.label || "").toLowerCase();
+          if (k && (i.class || "").toLowerCase() !== k) return false;
+          if (nm && !label.includes(nm)) return false;
+          if (dec && !String(attrOf(i, "decorators") || "").toLowerCase().includes(dec)) return false;
+          if (q && !label.includes(q)) return false;
+          return true;
+        })
+        .map(toIndividual);
+      return hit({ results });
+    },
+
+    ask(query) {
+      const { content, tmct_ask } = ask(graph, String(query || ""));
+      return hit({ content, tmct_ask });
+    },
+  };
+
+  return svc;
+}
+
+/** The source-reaching services a graph-only provider satisfies with NO_SOURCE. */
+export { SOURCE_SERVICES };