@polycode-projects/the-mechanical-code-talker 0.2.0 → 0.4.0

package/src/memory/inspect.mjs

@@ -0,0 +1,141 @@
+// memory/inspect.mjs — seeing into the memory as TEXT (ROADMAP Phase 4,
+// "Memory inspection"). One renderer serves both surfaces — the `/memory` chat
+// command and the `tmct memory` CLI — in a terse (default) and a verbose form:
+//
+//   - the memory graph grouped by OWL superclass (Fact / Utterance / Session,
+//     plus any other class present), counts with BALANCED samples scaled
+//     log-wise to class size (a 10,000-fact class shows ~8 exemplars, a
+//     3-session class shows all 3);
+//   - top facts ranked by PROVENANCE BREADTH (a fact the corpus AND the chat
+//     both asserted outranks a single-writer fact), provenance verbatim;
+//   - recent Q→A utterance pairs (read off the mgx:inReplyTo edges);
+//   - the block-index summary (blocks, indexed tokens, top PageRank blocks).
+//
+// Pure renderers over loaded payloads + one thin I/O wrapper (inspectMemory).
+// Everything degrades honestly: an empty memory renders as the empty story,
+// never an error.
+
+import { loadMemory, UTTERANCE_CLASS, IN_REPLY_TO_PROP, readFactRows, findContradictions } from "./core.mjs";
+import { loadBlockIndex } from "./blocks.mjs";
+
+/** Log-scaled sample count for a class of `n` individuals: 2·log10(n), floored
+ *  at 3, never more than n (10,000 → 8; 500 → 5; 3 → 3; 1 → 1). Verbose doubles. */
+export function sampleSize(n, { verbose = false } = {}) {
+  const base = Math.max(3, Math.round(2 * Math.log10(Math.max(1, n))));
+  return Math.min(n, verbose ? base * 2 : base);
+}
+
+/** Evenly-spaced (balanced) deterministic sample of k items — spans the class
+ *  start to end rather than showing the first k. */
+export function balancedSample(items, k) {
+  const n = items.length;
+  if (n <= k) return items.slice();
+  if (k <= 1) return [items[0]];
+  const out = [];
+  for (let i = 0; i < k; i += 1) out.push(items[Math.round((i * (n - 1)) / (k - 1))]);
+  return out;
+}
+
+const attrOf = (ind, key) => (ind?.attributes || []).find((a) => a.key === key)?.value || "";
+const truncate = (s, cap) => {
+  const t = String(s ?? "").replace(/\s+/g, " ").trim();
+  return t.length > cap ? `${t.slice(0, cap - 1)}…` : t;
+};
+
+/** Render a loaded memory payload + block index into the inspection text.
+ *  Pure. `verbose` widens every cap and stops truncating provenance/text. */
+export function renderMemory({ memory, blocks }, { verbose = false } = {}) {
+  const individuals = memory?.individuals || [];
+  const lines = [];
+  const textCap = verbose ? 400 : 100;
+
+  if (!individuals.length) {
+    lines.push("memory is empty — nothing remembered yet (facts, utterances and sessions land in .tmct/memory/ as you chat).");
+  } else {
+    // ---- classes: counts + balanced log-scaled samples ----
+    const byClass = new Map();
+    for (const ind of individuals) {
+      const cls = ind?.class || "(unclassified)";
+      if (!byClass.has(cls)) byClass.set(cls, []);
+      byClass.get(cls).push(ind);
+    }
+    const classes = [...byClass.entries()].sort((a, b) => b[1].length - a[1].length);
+    lines.push(`memory — ${individuals.length} individuals: ${classes.map(([c, of]) => `${of.length} ${c}`).join(", ")}.`);
+    for (const [cls, of] of classes) {
+      const k = sampleSize(of.length, { verbose });
+      lines.push("", `${cls} — ${of.length} (showing ${k})`);
+      for (const ind of balancedSample(of, k)) lines.push(`  ${truncate(ind.label, textCap)}`);
+    }
+
+    // ---- top facts by COMPUTED TRUST (upgraded from raw provenance breadth) ----
+    // Trust folds source-type prior + corroboration + recency, so a corroborated
+    // operator-stated fact outranks a lone web scrape by construction; provenance
+    // rides along (verbatim in verbose) for the audit trail.
+    const ranked = readFactRows(memory)
+      .filter((r) => r.sourceIds.length || r.provenance)
+      .sort((a, b) => b.trust - a.trust
+        || b.sourceIds.length - a.sourceIds.length
+        || `${a.subject} ${a.predicate} ${a.object}`.localeCompare(`${b.subject} ${b.predicate} ${b.object}`));
+    if (ranked.length) {
+      lines.push("", "top facts by trust:");
+      for (const r of ranked.slice(0, verbose ? 8 : 3)) {
+        const n = r.sourceIds.length || (r.provenance ? r.provenance.split(" | ").filter(Boolean).length : 0);
+        const label = `${r.subject} ${r.predicate} ${r.object}`;
+        lines.push(`  ${truncate(label, textCap)} — trust ${r.trust.toFixed(2)}, ${n} source${n === 1 ? "" : "s"}: ${verbose ? r.provenance : truncate(r.provenance, 80)}`);
+      }
+    }
+
+    // ---- contradictions: same (subject,predicate), differing object, both above
+    //      the trust floor → surface BOTH with provenance, never silently pick ----
+    const contradictions = findContradictions(memory);
+    if (contradictions.length) {
+      lines.push("", `contradictions (${contradictions.length} — both kept, never silently resolved):`);
+      for (const group of contradictions.slice(0, verbose ? 8 : 3)) {
+        lines.push(`  ${group[0].subject} ${group[0].predicate}?`);
+        for (const r of group) {
+          lines.push(`    ${truncate(r.object, textCap)} (trust ${r.trust.toFixed(2)}; ${verbose ? r.provenance : truncate(r.provenance, 60)})`);
+        }
+      }
+    }
+
+    // ---- recent Q→A pairs (off the inReplyTo edges) ----
+    const byId = new Map(individuals.map((i) => [i.id, i]));
+    const replyGroup = (memory.objectProperties || []).find((g) => g?.prop === IN_REPLY_TO_PROP);
+    const pairs = (replyGroup?.examples || [])
+      .map((e) => ({ a: byId.get(e.subject), q: byId.get(e.object) }))
+      .filter((p) => p.a && p.q && p.a.class === UTTERANCE_CLASS)
+      .sort((x, y) => attrOf(y.a, "ts").localeCompare(attrOf(x.a, "ts")));
+    if (pairs.length) {
+      lines.push("", `recent Q→A pairs (${pairs.length} recorded):`);
+      for (const p of pairs.slice(0, verbose ? 8 : 3)) {
+        lines.push(`  Q: ${truncate(attrOf(p.q, "text"), textCap)}`);
+        lines.push(`  A: ${truncate(attrOf(p.a, "text"), textCap)}`);
+      }
+    }
+  }
+
+  // ---- block-index summary ----
+  const entries = Object.entries(blocks?.blocks || {});
+  if (entries.length) {
+    const tokens = entries.reduce((n, [, b]) => n + (b.tokens?.length || 0), 0);
+    const top = entries
+      .slice()
+      .sort((a, b) => (b[1].rank ?? 0) - (a[1].rank ?? 0) || a[0].localeCompare(b[0]))
+      .slice(0, verbose ? 8 : 3);
+    lines.push("", `blocks — ${entries.length} folded session block${entries.length === 1 ? "" : "s"}, ${tokens} indexed tokens.`);
+    lines.push(`  top by rank: ${top.map(([id, b]) => `${String(id).slice(0, 8)} (${(b.rank ?? 0).toFixed(3)})`).join(", ")}`);
+  } else {
+    lines.push("", "blocks — none folded yet (a session folds when it ends).");
+  }
+
+  return lines.join("\n");
+}
+
+/** Load + render a repo's memory (the one thin I/O wrapper both the `/memory`
+ *  chat command and the `tmct memory` CLI call). Never throws on a missing
+ *  store — that is the honest empty story. */
+export async function inspectMemory(dir, { verbose = false } = {}) {
+  const memory = await loadMemory(dir);
+  const blocks = await loadBlockIndex(dir);
+  return renderMemory({ memory, blocks }, { verbose });
+}

package/src/memory/trust.mjs

@@ -0,0 +1,113 @@
+// memory/trust.mjs — deterministic, explainable, auditable trust over a Fact's
+// Sources (PLAN_PROVENANCE_TRUST step (c)).
+//
+// Trust is a COMPUTED attribute of a Fact — never hand-set — a pure function of
+// its Source edges, those Sources' types, and its mgx:createdAt. Three inputs
+// combine:
+//   - a Source-TYPE PRIOR (operator > provider > corpus > web > entailed);
+//   - CORROBORATION over the fact's distinct Sources by noisy-OR
+//     (1 − Π(1 − wᵢ), capped at 1) — two independent web sources (0.4) reach
+//     0.64, a lone operator fact is already 1.0;
+//   - a bounded RECENCY nudge in [0.9, 1.0] from createdAt, half-life decayed —
+//     the codegraph "capped nudge" philosophy, so recency breaks ties and
+//     freshens but never flips a source-type ordering by itself.
+//
+// For ENTAILED facts (tier-5): trust = min(premise trusts) × rule-confidence — a
+// conclusion is only as trustworthy as its weakest premise. Premises may be
+// absent for now, so this is a documented HOOK: pass opts.premiseTrusts (and
+// opts.ruleConfidence) and it engages; otherwise an entailed fact scores off its
+// bare 0.3 prior like any other Source.
+//
+// This module is PURE and import-free of core.mjs (no cycle): it reads Source
+// individuals by their attribute props and returns { score, inputs }. core.mjs
+// materialises the score onto the Fact (mgx:trustScore) plus the inputs it was
+// computed from (mgx:trustInputs), so every score is reproducible and auditable.
+
+export const TRUST_SCORE_PROP = "mgx:trustScore";
+export const TRUST_INPUTS_PROP = "mgx:trustInputs";
+
+/** Source-type priors — the ordering operator > provider-graph > curated-corpus
+ *  > web > unverified-entailment. The entailed value is a FLOOR before premise
+ *  adjustment (see the entailed hook below). */
+export const SOURCE_PRIOR = Object.freeze({
+  operator: 1.0,
+  provider: 0.9,
+  corpus: 0.7,
+  web: 0.4,
+  entailed: 0.3,
+});
+
+export const RECENCY_HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+export const RECENCY_FLOOR = 0.9; // recency multiplier stays within [0.9, 1.0]
+
+const round = (n, p = 6) => Number(n.toFixed(p));
+const sourceTypeOf = (s) => (s?.attributes || []).find((a) => a.prop === "mgx:sourceType")?.value || "";
+
+/**
+ * Bounded recency multiplier in [RECENCY_FLOOR, 1] from an ISO-8601 createdAt.
+ * A half-life decay: freshly written ≈ 1.0, ancient → RECENCY_FLOOR. An unknown
+ * or unparseable timestamp yields 1.0 (no penalty) — recency only ever nudges
+ * down from a full score, it never invents one.
+ */
+export function recencyNudge(createdAt, now = Date.now(), halfLifeMs = RECENCY_HALF_LIFE_MS) {
+  const t = Date.parse(createdAt);
+  if (!Number.isFinite(t)) return 1;
+  const ageMs = Math.max(0, now - t);
+  return RECENCY_FLOOR + (1 - RECENCY_FLOOR) * Math.pow(0.5, ageMs / halfLifeMs);
+}
+
+/**
+ * Pure trust for one Fact. `fact` supplies `{ sourceIds: [...], createdAt }`;
+ * the Source individuals are resolved from `sourcesById` (a plain { id: Source }
+ * map — exactly what a memory payload's Source individuals key into). Distinct
+ * sources are corroborated by noisy-OR over their type priors and nudged by
+ * recency. Deterministic given the same inputs and `opts.now`.
+ *
+ * opts:
+ *   - now            (ms) reference time for recency; default Date.now()
+ *   - halfLifeMs     recency half-life override
+ *   - premiseTrusts  entailed hook: [trusts] of the conclusion's premise Facts
+ *   - ruleConfidence entailed hook: the rule's confidence in [0,1] (default 1)
+ *
+ * Returns { score, inputs } — `inputs` (the source-type multiset, corroboration
+ * count, createdAt and the recency multiplier) is stored alongside the score so
+ * "why does this rank high?" is answerable from the record.
+ */
+export function computeTrust(fact, sourcesById = {}, opts = {}) {
+  const now = typeof opts.now === "number" ? opts.now : Date.now();
+  const ids = Array.isArray(fact?.sourceIds) ? fact.sourceIds : [];
+
+  // distinct sources → their type priors
+  const seen = new Set();
+  const types = [];
+  for (const id of ids) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const t = sourceTypeOf(sourcesById[id]);
+    if (t) types.push(t);
+  }
+
+  // corroboration via noisy-OR over distinct-source priors, capped at 1
+  let base = 0;
+  let complement = 1;
+  for (const t of types) complement *= 1 - (SOURCE_PRIOR[t] ?? 0);
+  if (types.length) base = Math.min(1, 1 - complement);
+
+  // entailed hook (tier-5): a conclusion is only as trustworthy as its weakest
+  // premise × the rule confidence. Engages only when premises are supplied;
+  // otherwise an entailed fact rides its bare prior through the noisy-OR above.
+  if (types.includes("entailed") && Array.isArray(opts.premiseTrusts) && opts.premiseTrusts.length) {
+    const rc = typeof opts.ruleConfidence === "number" ? opts.ruleConfidence : 1;
+    base = Math.max(0, Math.min(1, Math.min(...opts.premiseTrusts) * rc));
+  }
+
+  const recency = recencyNudge(fact?.createdAt, now, opts.halfLifeMs);
+  const score = round(Math.min(1, base * recency));
+  const inputs = {
+    sourceTypes: types.slice().sort(),
+    corroboration: types.length,
+    createdAt: fact?.createdAt || "",
+    recency: round(recency),
+  };
+  return { score, inputs };
+}

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());
+}