eminiar 0.6.2 → 0.8.0

package/dist/cli.js

@@ -26524,9 +26524,9 @@ var require_parse2 = __commonJS({
                 const idx = prev.value.lastIndexOf("[");
                 const pre = prev.value.slice(0, idx);
                 const rest3 = prev.value.slice(idx + 2);
-                const posix = POSIX_REGEX_SOURCE[rest3];
-                if (posix) {
-                  prev.value = pre + posix;
+                const posix2 = POSIX_REGEX_SOURCE[rest3];
+                if (posix2) {
+                  prev.value = pre + posix2;
                   state.backtrack = true;
                   advance();
                   if (!bos.output && tokens.indexOf(prev) === 1) {
@@ -27048,7 +27048,7 @@ var require_picomatch = __commonJS({
         throw new TypeError("Expected pattern to be a non-empty string");
       }
       const opts = options || {};
-      const posix = utils.isWindows(options);
+      const posix2 = utils.isWindows(options);
       const regex = isState ? picomatch.compileRe(glob2, options) : picomatch.makeRe(glob2, options, false, true);
       const state = regex.state;
       delete regex.state;
@@ -27058,8 +27058,8 @@ var require_picomatch = __commonJS({
         isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
       }
       const matcher = (input2, returnObject = false) => {
-        const { isMatch, match, output: output2 } = picomatch.test(input2, regex, options, { glob: glob2, posix });
-        const result = { glob: glob2, state, regex, posix, input: input2, output: output2, match, isMatch };
+        const { isMatch, match, output: output2 } = picomatch.test(input2, regex, options, { glob: glob2, posix: posix2 });
+        const result = { glob: glob2, state, regex, posix: posix2, input: input2, output: output2, match, isMatch };
         if (typeof opts.onResult === "function") {
           opts.onResult(result);
         }
@@ -27084,7 +27084,7 @@ var require_picomatch = __commonJS({
       }
       return matcher;
     };
-    picomatch.test = (input2, regex, options, { glob: glob2, posix } = {}) => {
+    picomatch.test = (input2, regex, options, { glob: glob2, posix: posix2 } = {}) => {
       if (typeof input2 !== "string") {
         throw new TypeError("Expected input to be a string");
       }
@@ -27092,7 +27092,7 @@ var require_picomatch = __commonJS({
         return { isMatch: false, output: "" };
       }
       const opts = options || {};
-      const format = opts.format || (posix ? utils.toPosixSlashes : null);
+      const format = opts.format || (posix2 ? utils.toPosixSlashes : null);
       let match = input2 === glob2;
       let output2 = match && format ? format(input2) : input2;
       if (match === false) {
@@ -27101,14 +27101,14 @@ var require_picomatch = __commonJS({
       }
       if (match === false || opts.capture === true) {
         if (opts.matchBase === true || opts.basename === true) {
-          match = picomatch.matchBase(input2, regex, options, posix);
+          match = picomatch.matchBase(input2, regex, options, posix2);
         } else {
           match = regex.exec(output2);
         }
       }
       return { isMatch: Boolean(match), match, output: output2 };
     };
-    picomatch.matchBase = (input2, glob2, options, posix = utils.isWindows(options)) => {
+    picomatch.matchBase = (input2, glob2, options, posix2 = utils.isWindows(options)) => {
       const regex = glob2 instanceof RegExp ? glob2 : picomatch.makeRe(glob2, options);
       return regex.test(path3.basename(input2));
     };
@@ -27299,9 +27299,9 @@ var require_micromatch = __commonJS({
       return [].concat(patterns).every((p) => picomatch(p, options)(str2));
     };
     micromatch.capture = (glob2, input2, options) => {
-      let posix = utils.isWindows(options);
+      let posix2 = utils.isWindows(options);
       let regex = picomatch.makeRe(String(glob2), { ...options, capture: true });
-      let match = regex.exec(posix ? utils.toPosixSlashes(input2) : input2);
+      let match = regex.exec(posix2 ? utils.toPosixSlashes(input2) : input2);
       if (match) {
         return match.slice(1).map((v) => v === void 0 ? "" : v);
       }
@@ -27481,15 +27481,15 @@ var require_pattern = __commonJS({
     exports.removeDuplicateSlashes = removeDuplicateSlashes;
     function partitionAbsoluteAndRelative(patterns) {
       const absolute = [];
-      const relative10 = [];
+      const relative11 = [];
       for (const pattern2 of patterns) {
         if (isAbsolute(pattern2)) {
           absolute.push(pattern2);
         } else {
-          relative10.push(pattern2);
+          relative11.push(pattern2);
         }
       }
-      return [absolute, relative10];
+      return [absolute, relative11];
     }
     exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
     function isAbsolute(pattern2) {
@@ -27920,11 +27920,11 @@ var require_out = __commonJS({
       async.read(path3, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports.stat = stat;
-    function statSync11(path3, optionsOrSettings) {
+    function statSync12(path3, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path3, settings);
     }
-    exports.statSync = statSync11;
+    exports.statSync = statSync12;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -29804,19 +29804,19 @@ var require_out4 = __commonJS({
         return utils.path.convertPathToPattern(source);
       }
       FastGlob2.convertPathToPattern = convertPathToPattern;
-      let posix;
-      (function(posix2) {
+      let posix2;
+      (function(posix3) {
         function escapePath2(source) {
           assertPatternsInput(source);
           return utils.path.escapePosixPath(source);
         }
-        posix2.escapePath = escapePath2;
+        posix3.escapePath = escapePath2;
         function convertPathToPattern2(source) {
           assertPatternsInput(source);
           return utils.path.convertPosixPathToPattern(source);
         }
-        posix2.convertPathToPattern = convertPathToPattern2;
-      })(posix = FastGlob2.posix || (FastGlob2.posix = {}));
+        posix3.convertPathToPattern = convertPathToPattern2;
+      })(posix2 = FastGlob2.posix || (FastGlob2.posix = {}));
       let win32;
       (function(win322) {
         function escapePath2(source) {
@@ -30776,13 +30776,14 @@ function fileOf(id) {
   if (kind === "sym") return rest2.split("#")[0];
   return void 0;
 }
-var fileId, memoryId, symId, pkgId, personId, conceptId;
+var fileId, memoryId, docId, symId, pkgId, personId, conceptId;
 var init_ids = __esm({
   "src/graph/ids.ts"() {
     "use strict";
     init_esm_shims();
     fileId = (rel) => `file:${rel}`;
     memoryId = (name) => `memory:${name}`;
+    docId = (name) => `doc:${name}`;
     symId = (rel, name) => `sym:${rel}#${name}`;
     pkgId = (name) => `pkg:${name}`;
     personId = (name) => `person:${name}`;
@@ -31152,9 +31153,10 @@ function impact(db, ref, opts = {}) {
     frontier = next;
     if (!frontier.length) break;
   }
-  for (const e of db.graphEdgesTo(start, ["mentions"])) {
+  for (const e of db.graphEdgesTo(start, ["mentions", "documents"])) {
     const via = e.dst === root.id ? root.name : e.dst.replace(/^sym:[^#]*#/, "");
-    add(e.src, 0.5 * e.confidence, 1, `memory mentions ${via}`);
+    const who = e.kind === "documents" ? "doc documents" : "memory mentions";
+    add(e.src, 0.5 * e.confidence, 1, `${who} ${via}`);
   }
   if (opts.includeGit !== false) {
     const file3 = toFile(root.id);
@@ -35514,10 +35516,13 @@ __export(store_exports, {
   isValidName: () => isValidName,
   list: () => list,
   memoriesDir: () => memoriesDir,
+  memoriesRel: () => memoriesRel,
+  memoryLinks: () => memoryLinks,
   normalizeRelated: () => normalizeRelated,
   read: () => read,
   reconcile: () => reconcile,
   relOf: () => relOf,
+  relatedTarget: () => relatedTarget,
   remove: () => remove,
   rename: () => rename,
   setMeta: () => setMeta,
@@ -35593,6 +35598,17 @@ function normalizeRelated(ids) {
   }
   return [...out];
 }
+function relatedTarget(id) {
+  return id.startsWith("mem:") ? memoryId(id.slice(4)) : id;
+}
+function memoryLinks(body, self) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of body.matchAll(MEM_LINK_RE)) {
+    const name = m[1].replace(/[.-]+$/, "");
+    if (name && name !== self && isValidName(name)) out.add(name);
+  }
+  return [...out];
+}
 function writeMemoryFile(ctx, name, meta4, body) {
   const abs = absOf(ctx, name);
   mkdirSync7(dirname8(abs), { recursive: true });
@@ -35600,36 +35616,30 @@ function writeMemoryFile(ctx, name, meta4, body) {
 ${body.trim()}
 `));
 }
-function syncGraph(db, name, rel, kind, tags, related, supersedes) {
+function syncGraph(db, name, rel, g) {
+  const self = memoryId(name);
   db.graphDeleteForPath("curated", rel);
   db.graphUpsertNodes([
     {
-      id: memoryId(name),
+      id: self,
       kind: "memory",
       name,
       path: rel,
       source: "curated",
-      meta: { kind, tags }
+      meta: { kind: g.kind, tags: g.tags, ...g.status ? { status: g.status } : {} }
     }
   ]);
-  const edges = related.map((dst) => ({
-    src: memoryId(name),
-    dst,
-    kind: "mentions",
-    source: "curated",
-    confidence: 1,
-    weight: 1
-  }));
-  if (supersedes) {
-    edges.push({
-      src: memoryId(name),
-      dst: memoryId(supersedes),
-      kind: "supersedes",
-      source: "curated",
-      confidence: 1,
-      weight: 1
-    });
-  }
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (dst, kind) => {
+    const key = `${kind}|${dst}`;
+    if (dst === self || seen.has(key)) return;
+    seen.add(key);
+    edges.push({ src: self, dst, kind, source: "curated", confidence: 1, weight: 1 });
+  };
+  for (const id of g.related) push(relatedTarget(id), "mentions");
+  for (const other of memoryLinks(g.body, name)) push(memoryId(other), "links");
+  if (g.supersedes) push(memoryId(g.supersedes.replace(/^mem(?:ory)?:/, "")), "supersedes");
   if (edges.length) db.graphUpsertEdges(edges);
 }
 function forgetInDb(db, name, rel) {
@@ -35716,7 +35726,7 @@ tags: ${tags.join(", ")}` : ""}`,
     status,
     supersedes
   });
-  syncGraph(db, name, rel, kind, tags, related, supersedes);
+  syncGraph(db, name, rel, { kind, tags, related, status, supersedes, body });
   return { changed: true, row: db.memoryGetByName(name) };
 }
 function setMeta(ctx, db, name, patch) {
@@ -35919,7 +35929,7 @@ function gitignoreHint(ctx) {
   const ignored = readFileSync16(file3, "utf8").split(/\r?\n/).map((l) => l.trim().replace(/^\//, "").replace(/\/$/, "")).some((l) => l === top || l === dir || l === `${top}/**` || l === `${dir}/**`);
   return ignored ? `note: .gitignore ignores ${dir}, so memories stay local to this machine (remove that line to share them with the team)` : void 0;
 }
-var import_fast_glob3, MEMORY_KINDS, SEGMENT, NAME_RE, hinted;
+var import_fast_glob3, MEMORY_KINDS, SEGMENT, NAME_RE, MEM_LINK_RE, hinted;
 var init_store = __esm({
   "src/memory/store.ts"() {
     "use strict";
@@ -35941,6 +35951,7 @@ var init_store = __esm({
     ];
     SEGMENT = "[a-z0-9][a-z0-9._-]*";
     NAME_RE = new RegExp(`^(?:${SEGMENT}/)?${SEGMENT}$`);
+    MEM_LINK_RE = /(?<![A-Za-z0-9_./-])mem:([a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._-]*)?)/g;
     hinted = /* @__PURE__ */ new Set();
   }
 });
@@ -36626,7 +36637,7 @@ function architecture(ctx, db, aspects = ASPECTS) {
   for (const l of languages2.values()) langCounts[l] = (langCounts[l] ?? 0) + 1;
   const counts = db.graphCounts();
   const nodeCounts = db.graphNodeCounts();
-  const symbols = Object.entries(nodeCounts).filter(([k]) => !["file", "package", "person", "concept", "memory"].includes(k)).reduce((a, [, n]) => a + n, 0);
+  const symbols = Object.entries(nodeCounts).filter(([k]) => !["file", "package", "person", "concept", "memory", "doc"].includes(k)).reduce((a, [, n]) => a + n, 0);
   const out = {
     project: {
       name: typeof pkg.name === "string" ? pkg.name : void 0,
@@ -39030,6 +39041,341 @@ var init_discover = __esm({
   }
 });
 
+// src/docs/category.ts
+function categoryInfo(id) {
+  return BY_ID.get(id) ?? BY_ID.get("local");
+}
+function localCategory(s) {
+  const title = s.title ?? "";
+  for (const [re, cat] of TITLE_RULES) if (re.test(title)) return cat;
+  for (const [re, cat] of NAME_RULES) if (re.test(s.name)) return cat;
+  const path3 = s.path ?? "";
+  if (/(^|\/)(adrs?|decisions)$/i.test(path3)) return "adr";
+  const globs = s.glob ?? [];
+  const hits = /* @__PURE__ */ new Map();
+  for (const g of globs)
+    for (const [re, cat] of GLOB_RULES)
+      if (re.test(g)) {
+        hits.set(cat, (hits.get(cat) ?? 0) + 1);
+        break;
+      }
+  if (hits.size) return [...hits.entries()].sort((a, b) => b[1] - a[1])[0][0];
+  if (/(^|\/)(docs?|documentation)$/i.test(path3)) return "guides";
+  if (/README|CONTRIBUTING|CHANGELOG/i.test(path3)) return "readme";
+  return "local";
+}
+function docCategory(s, entry) {
+  if (s.kind === "path") return localCategory(s);
+  if (entry) {
+    const tier = entry.tier ?? "library";
+    return tier === "service" ? "service" : tier === "infra" ? "infra" : "library";
+  }
+  const provider = s.provider ?? "";
+  const i = provider.indexOf(":");
+  const kind = i === -1 ? provider : provider.slice(0, i);
+  switch (kind) {
+    case "api":
+      return "api";
+    case "env":
+      return "service";
+    case "image":
+    case "files":
+      return "infra";
+    case "npm":
+    case "pypi":
+    case "go":
+      return "library";
+    default:
+      return "web";
+  }
+}
+function categoryRank(id) {
+  const i = DOC_CATEGORIES.findIndex((c) => c.id === id);
+  return i === -1 ? DOC_CATEGORIES.length : i;
+}
+var DOC_CATEGORIES, BY_ID, GROUP_LABELS, TITLE_RULES, NAME_RULES, GLOB_RULES;
+var init_category = __esm({
+  "src/docs/category.ts"() {
+    "use strict";
+    init_esm_shims();
+    DOC_CATEGORIES = [
+      {
+        id: "readme",
+        group: "project",
+        label: "Readme & guides",
+        blurb: "README, CONTRIBUTING, CHANGELOG and other top-level guides"
+      },
+      {
+        id: "guides",
+        group: "project",
+        label: "Docs folders",
+        blurb: "docs/ directories: handbooks, how-tos, references"
+      },
+      {
+        id: "adr",
+        group: "project",
+        label: "Decision records",
+        blurb: "architecture decision records"
+      },
+      {
+        id: "agent-instructions",
+        group: "project",
+        label: "Agent instructions",
+        blurb: "Copilot, Claude and Cursor instructions, agents and skills"
+      },
+      {
+        id: "api-specs",
+        group: "project",
+        label: "API specs",
+        blurb: "OpenAPI, Postman, GraphQL and protobuf definitions"
+      },
+      {
+        id: "env-reference",
+        group: "project",
+        label: "Environment reference",
+        blurb: ".env examples: every variable the project reads"
+      },
+      {
+        id: "deploy-config",
+        group: "project",
+        label: "Deploy config",
+        blurb: "Terraform, Kubernetes, Helm, Compose and CI workflows"
+      },
+      { id: "local", group: "project", label: "Other local files", blurb: "hand-registered paths" },
+      {
+        id: "service",
+        group: "external",
+        label: "Services",
+        blurb: "third-party products and APIs the project integrates"
+      },
+      {
+        id: "api",
+        group: "external",
+        label: "External APIs",
+        blurb: "hosts the code calls, found by probing their docs"
+      },
+      {
+        id: "infra",
+        group: "external",
+        label: "Infrastructure",
+        blurb: "platforms the project runs on"
+      },
+      { id: "library", group: "external", label: "Libraries", blurb: "frameworks and packages" },
+      { id: "web", group: "external", label: "Web pages", blurb: "hand-registered URLs" }
+    ];
+    BY_ID = new Map(DOC_CATEGORIES.map((c) => [c.id, c]));
+    GROUP_LABELS = {
+      project: "Project documentation",
+      external: "External documentation"
+    };
+    TITLE_RULES = [
+      [/^project readme/i, "readme"],
+      [/^(docs|doc|documentation)\/ directory$/i, "guides"],
+      [/decision records/i, "adr"],
+      [/copilot|claude|cursor/i, "agent-instructions"],
+      [/openapi|postman|graphql|protobuf/i, "api-specs"],
+      [/environment variable/i, "env-reference"],
+      [/terraform|kubernetes|helm|compose|workflow/i, "deploy-config"]
+    ];
+    NAME_RULES = [
+      [/(^|-)readme$/, "readme"],
+      [/(^|-)docs$/, "guides"],
+      [/(^|-)adrs?$/, "adr"],
+      [/(^|-)agent-instructions$/, "agent-instructions"],
+      [/(^|-)api-specs$/, "api-specs"],
+      [/(^|-)env-example$/, "env-reference"],
+      [/(^|-)deploy-config$/, "deploy-config"]
+    ];
+    GLOB_RULES = [
+      [/openapi|swagger|postman_collection|asyncapi|\.graphql$|\.proto$/i, "api-specs"],
+      [/^\.env\./, "env-reference"],
+      [
+        /\.tf$|tfvars|^k8s\/|^helm\/|^charts\/|^manifests\/|compose.*\.ya?ml|\.github\/workflows/i,
+        "deploy-config"
+      ],
+      [
+        /copilot-instructions|\.github\/(instructions|agents|skills)|\.claude\/(agents|skills)|\.cursor\/rules|^(AGENTS|CLAUDE)\.md$/i,
+        "agent-instructions"
+      ],
+      [/^(README|CONTRIBUTING|CHANGELOG|SECURITY)(\.md)?$/i, "readme"],
+      [/^\*\*\/\*\.(md|mdx|rst|txt)$/i, "guides"]
+    ];
+  }
+});
+
+// src/docs/graph.ts
+import { existsSync as existsSync21, statSync as statSync9 } from "fs";
+import { dirname as dirname10, posix, relative as relative8, sep as sep2 } from "path";
+function manifestRel(ctx) {
+  return relative8(ctx.root, manifestPath(ctx)).split(sep2).join("/");
+}
+function packageCandidates(provider) {
+  if (!provider) return [];
+  const i = provider.indexOf(":");
+  if (i === -1) return [];
+  const kind = provider.slice(0, i);
+  const name = provider.slice(i + 1).trim();
+  if (!name) return [];
+  if (kind === "npm" || kind === "go") return [pkgId(name)];
+  if (kind === "pypi") {
+    const lower = name.toLowerCase();
+    return [.../* @__PURE__ */ new Set([pkgId(lower.replace(/-/g, "_")), pkgId(lower), pkgId(name)])];
+  }
+  return [];
+}
+function pathsIn(text3, pageRel, files) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of text3.matchAll(PATH_RE)) {
+    const raw = m[1];
+    const tries = [raw.replace(/^(\.\/)+/, "")];
+    if (pageRel && raw.startsWith("."))
+      tries.unshift(posix.normalize(posix.join(dirname10(pageRel), raw)));
+    for (const t of tries) {
+      if (files.has(t)) {
+        out.add(t);
+        break;
+      }
+    }
+  }
+  return [...out];
+}
+function pageRelOf(ctx, uri) {
+  if (!uri?.startsWith("file://")) return void 0;
+  const rel = relative8(ctx.root, uri.slice("file://".length)).split(sep2).join("/");
+  return rel.startsWith("..") ? void 0 : rel;
+}
+function localEdges(ctx, db, src, files) {
+  const id = docId(src.name);
+  const hits = /* @__PURE__ */ new Map();
+  for (const page of db.documentsBySource(docsTag(src.name), MAX_PAGES)) {
+    const rel = pageRelOf(ctx, page.uri);
+    if (rel && files.has(rel)) hits.set(rel, { via: "covers", count: 1 });
+    const text3 = db.chunksOfDocument(page.id).map((c) => c.body).join("\n");
+    for (const f of pathsIn(text3, rel, files)) {
+      const h = hits.get(f);
+      if (h) h.count++;
+      else hits.set(f, { via: "mentions", count: 1 });
+    }
+    if (hits.size >= MAX_EDGES) break;
+  }
+  return [...hits].sort((a, b) => b[1].count - a[1].count).slice(0, MAX_EDGES).map(([rel, h]) => ({
+    src: id,
+    dst: `file:${rel}`,
+    kind: DOCUMENTS_EDGE,
+    source: "curated",
+    confidence: h.via === "covers" ? 1 : 0.8,
+    weight: Math.min(1, 0.5 + h.count / 10),
+    meta: { via: h.via, count: h.count }
+  }));
+}
+function packageEdges(src, packages) {
+  const id = docId(src.name);
+  const cands = packageCandidates(src.provider);
+  if (!cands.length) return [];
+  let targets = cands.filter((c) => packages.has(c));
+  if (src.provider?.startsWith("go:"))
+    targets = [...targets, ...[...packages].filter((p) => p.startsWith(`${cands[0]}/`))];
+  if (!targets.length) targets = [cands[0]];
+  return [...new Set(targets)].map((dst) => ({
+    src: id,
+    dst,
+    kind: DOCUMENTS_EDGE,
+    source: "curated",
+    confidence: 1,
+    weight: 1,
+    meta: { via: "provider" }
+  }));
+}
+function localDocPages(ctx, db) {
+  const out = /* @__PURE__ */ new Map();
+  for (const s of readManifest(ctx).sources) {
+    if (s.kind !== "path") continue;
+    for (const page of db.documentsBySource(docsTag(s.name), MAX_PAGES)) {
+      const rel = pageRelOf(ctx, page.uri);
+      if (!rel) continue;
+      const names = out.get(rel) ?? [];
+      if (!names.includes(s.name)) names.push(s.name);
+      out.set(rel, names);
+    }
+  }
+  return out;
+}
+function stampOf(ctx, db) {
+  const file3 = manifestPath(ctx);
+  const st = existsSync21(file3) ? statSync9(file3) : void 0;
+  const counts = db.graphNodeCounts();
+  const syncs = readManifest(ctx).sources.map((s) => syncState(db, s.name)?.at ?? 0).join(",");
+  return `${st ? `${Math.floor(st.mtimeMs)}:${st.size}` : "none"}|${counts.file ?? 0}|${counts.package ?? 0}|${syncs}`;
+}
+function syncDocsGraph(ctx, db) {
+  const rel = manifestRel(ctx);
+  const m = readManifest(ctx);
+  const catalog = mergedCatalog(ctx.config.docs.catalog);
+  const files = new Set(
+    db.graphFileNodes().filter((n) => n.source === "tree-sitter" && n.path).map((n) => n.path)
+  );
+  const packages = new Set(db.graphNodesByKind(["package"]).map((n) => n.id));
+  const nodes = [];
+  const edges = [];
+  for (const s of m.sources) {
+    const category = docCategory(
+      s,
+      s.provider ? catalogForProvider(s.provider, catalog) : void 0
+    );
+    nodes.push({
+      id: docId(s.name),
+      kind: "doc",
+      name: s.name,
+      path: rel,
+      source: "curated",
+      meta: {
+        category,
+        group: categoryInfo(category).group,
+        sourceKind: s.kind,
+        ...s.provider ? { provider: s.provider } : {},
+        ...s.title ? { title: s.title } : {},
+        ...s.tags?.length ? { tags: s.tags } : {},
+        ...s.kind === "path" ? { target: s.path } : { url: s.urls?.[0] },
+        documents: db.countDocuments(docsTag(s.name))
+      }
+    });
+    edges.push(...packageEdges(s, packages));
+    if (s.kind === "path") edges.push(...localEdges(ctx, db, s, files));
+  }
+  db.graphDeleteForPath("curated", rel, { keepFile: true });
+  if (nodes.length) db.graphUpsertNodes(nodes);
+  if (edges.length) db.graphUpsertEdges(edges);
+  db.metaSet(STAMP_KEY, stampOf(ctx, db));
+  return { sources: nodes.length, edges: edges.length };
+}
+function ensureDocsGraph(ctx, db) {
+  if (db.metaGet(STAMP_KEY) === stampOf(ctx, db)) return false;
+  syncDocsGraph(ctx, db);
+  return true;
+}
+function syncDocsGraphQuietly(ctx, db) {
+  try {
+    syncDocsGraph(ctx, db);
+  } catch {
+  }
+}
+var DOCUMENTS_EDGE, MAX_PAGES, MAX_EDGES, PATH_RE, STAMP_KEY;
+var init_graph = __esm({
+  "src/docs/graph.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_ids();
+    init_catalog();
+    init_category();
+    init_manifest();
+    DOCUMENTS_EDGE = "documents";
+    MAX_PAGES = 500;
+    MAX_EDGES = 400;
+    PATH_RE = /(?:^|[\s(`'"[<])((?:\.{1,2}\/)*(?:[\w@.-]+\/)+[\w@.-]+\.[A-Za-z0-9]{1,8})(?=$|[\s)`'"\]>:#,;!?]|\.(?:\s|$))/gm;
+    STAMP_KEY = "docs.graph.stamp";
+  }
+});
+
 // src/docs/resolve.ts
 async function getJson(url2, opts) {
   const f = opts.fetchImpl ?? fetch;
@@ -39914,6 +40260,7 @@ async function syncSources(ctx, db, names, opts = {}) {
       });
   }
   for (const src of wanted) out.push(await syncSource(ctx, db, src, opts));
+  syncDocsGraphQuietly(ctx, db);
   return out;
 }
 function formatSync(results) {
@@ -39943,6 +40290,7 @@ var init_sync = __esm({
     init_queue();
     init_fetcher();
     init_indexer();
+    init_graph();
     init_manifest();
     init_specs();
     SKIP_EXT2 = /\.(png|jpe?g|gif|svg|webp|ico|css|js|mjs|map|zip|gz|tgz|tar|pdf|woff2?|ttf|otf|eot|mp4|mp3|webm|xml|rss|atom|wasm)$/i;
@@ -40086,12 +40434,14 @@ async function addDocSources(ctx, db, inputs, opts = {}) {
   const names = [...out.added, ...out.updated];
   if (opts.sync !== false && names.length)
     out.sync = await syncSources(ctx, db, names, { force: opts.force });
+  else if (names.length) syncDocsGraphQuietly(ctx, db);
   return out;
 }
 function removeDocSource(ctx, db, name) {
   const removed = removeSource(ctx, name);
   const documents = db.deleteDocumentsBySource(docsTag(name));
   clearSyncState(db, name);
+  if (removed) syncDocsGraphQuietly(ctx, db);
   return { removed, documents };
 }
 function formatAdd(o) {
@@ -40125,6 +40475,7 @@ var init_add = __esm({
     init_esm_shims();
     init_catalog();
     init_discover();
+    init_graph();
     init_manifest();
     init_resolve2();
     init_sync();
@@ -40141,168 +40492,6 @@ var init_add = __esm({
   }
 });
 
-// src/docs/category.ts
-function categoryInfo(id) {
-  return BY_ID.get(id) ?? BY_ID.get("local");
-}
-function localCategory(s) {
-  const title = s.title ?? "";
-  for (const [re, cat] of TITLE_RULES) if (re.test(title)) return cat;
-  for (const [re, cat] of NAME_RULES) if (re.test(s.name)) return cat;
-  const path3 = s.path ?? "";
-  if (/(^|\/)(adrs?|decisions)$/i.test(path3)) return "adr";
-  const globs = s.glob ?? [];
-  const hits = /* @__PURE__ */ new Map();
-  for (const g of globs)
-    for (const [re, cat] of GLOB_RULES)
-      if (re.test(g)) {
-        hits.set(cat, (hits.get(cat) ?? 0) + 1);
-        break;
-      }
-  if (hits.size) return [...hits.entries()].sort((a, b) => b[1] - a[1])[0][0];
-  if (/(^|\/)(docs?|documentation)$/i.test(path3)) return "guides";
-  if (/README|CONTRIBUTING|CHANGELOG/i.test(path3)) return "readme";
-  return "local";
-}
-function docCategory(s, entry) {
-  if (s.kind === "path") return localCategory(s);
-  if (entry) {
-    const tier = entry.tier ?? "library";
-    return tier === "service" ? "service" : tier === "infra" ? "infra" : "library";
-  }
-  const provider = s.provider ?? "";
-  const i = provider.indexOf(":");
-  const kind = i === -1 ? provider : provider.slice(0, i);
-  switch (kind) {
-    case "api":
-      return "api";
-    case "env":
-      return "service";
-    case "image":
-    case "files":
-      return "infra";
-    case "npm":
-    case "pypi":
-    case "go":
-      return "library";
-    default:
-      return "web";
-  }
-}
-function categoryRank(id) {
-  const i = DOC_CATEGORIES.findIndex((c) => c.id === id);
-  return i === -1 ? DOC_CATEGORIES.length : i;
-}
-var DOC_CATEGORIES, BY_ID, GROUP_LABELS, TITLE_RULES, NAME_RULES, GLOB_RULES;
-var init_category = __esm({
-  "src/docs/category.ts"() {
-    "use strict";
-    init_esm_shims();
-    DOC_CATEGORIES = [
-      {
-        id: "readme",
-        group: "project",
-        label: "Readme & guides",
-        blurb: "README, CONTRIBUTING, CHANGELOG and other top-level guides"
-      },
-      {
-        id: "guides",
-        group: "project",
-        label: "Docs folders",
-        blurb: "docs/ directories: handbooks, how-tos, references"
-      },
-      {
-        id: "adr",
-        group: "project",
-        label: "Decision records",
-        blurb: "architecture decision records"
-      },
-      {
-        id: "agent-instructions",
-        group: "project",
-        label: "Agent instructions",
-        blurb: "Copilot, Claude and Cursor instructions, agents and skills"
-      },
-      {
-        id: "api-specs",
-        group: "project",
-        label: "API specs",
-        blurb: "OpenAPI, Postman, GraphQL and protobuf definitions"
-      },
-      {
-        id: "env-reference",
-        group: "project",
-        label: "Environment reference",
-        blurb: ".env examples: every variable the project reads"
-      },
-      {
-        id: "deploy-config",
-        group: "project",
-        label: "Deploy config",
-        blurb: "Terraform, Kubernetes, Helm, Compose and CI workflows"
-      },
-      { id: "local", group: "project", label: "Other local files", blurb: "hand-registered paths" },
-      {
-        id: "service",
-        group: "external",
-        label: "Services",
-        blurb: "third-party products and APIs the project integrates"
-      },
-      {
-        id: "api",
-        group: "external",
-        label: "External APIs",
-        blurb: "hosts the code calls, found by probing their docs"
-      },
-      {
-        id: "infra",
-        group: "external",
-        label: "Infrastructure",
-        blurb: "platforms the project runs on"
-      },
-      { id: "library", group: "external", label: "Libraries", blurb: "frameworks and packages" },
-      { id: "web", group: "external", label: "Web pages", blurb: "hand-registered URLs" }
-    ];
-    BY_ID = new Map(DOC_CATEGORIES.map((c) => [c.id, c]));
-    GROUP_LABELS = {
-      project: "Project documentation",
-      external: "External documentation"
-    };
-    TITLE_RULES = [
-      [/^project readme/i, "readme"],
-      [/^(docs|doc|documentation)\/ directory$/i, "guides"],
-      [/decision records/i, "adr"],
-      [/copilot|claude|cursor/i, "agent-instructions"],
-      [/openapi|postman|graphql|protobuf/i, "api-specs"],
-      [/environment variable/i, "env-reference"],
-      [/terraform|kubernetes|helm|compose|workflow/i, "deploy-config"]
-    ];
-    NAME_RULES = [
-      [/(^|-)readme$/, "readme"],
-      [/(^|-)docs$/, "guides"],
-      [/(^|-)adrs?$/, "adr"],
-      [/(^|-)agent-instructions$/, "agent-instructions"],
-      [/(^|-)api-specs$/, "api-specs"],
-      [/(^|-)env-example$/, "env-reference"],
-      [/(^|-)deploy-config$/, "deploy-config"]
-    ];
-    GLOB_RULES = [
-      [/openapi|swagger|postman_collection|asyncapi|\.graphql$|\.proto$/i, "api-specs"],
-      [/^\.env\./, "env-reference"],
-      [
-        /\.tf$|tfvars|^k8s\/|^helm\/|^charts\/|^manifests\/|compose.*\.ya?ml|\.github\/workflows/i,
-        "deploy-config"
-      ],
-      [
-        /copilot-instructions|\.github\/(instructions|agents|skills)|\.claude\/(agents|skills)|\.cursor\/rules|^(AGENTS|CLAUDE)\.md$/i,
-        "agent-instructions"
-      ],
-      [/^(README|CONTRIBUTING|CHANGELOG|SECURITY)(\.md)?$/i, "readme"],
-      [/^\*\*\/\*\.(md|mdx|rst|txt)$/i, "guides"]
-    ];
-  }
-});
-
 // src/tools/em_docs.ts
 var em_docs_exports = {};
 __export(em_docs_exports, {
@@ -41003,8 +41192,8 @@ var init_em_search = __esm({
 });
 
 // src/ui/api.ts
-import { existsSync as existsSync21, readdirSync as readdirSync8 } from "fs";
-import { join as join26, relative as relative8 } from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync8 } from "fs";
+import { join as join26, relative as relative9 } from "path";
 function listProjects() {
   const dir = paths().projects;
   const out = [];
@@ -41037,7 +41226,7 @@ function statsPayload(ctx) {
   const sessionId = getCurrentSession(ctx);
   const g = globalDb();
   const onboardingDir = join26(memoriesDir(ctx), "onboarding");
-  const onboarding = existsSync21(onboardingDir) ? readdirSync8(onboardingDir).filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3)) : [];
+  const onboarding = existsSync22(onboardingDir) ? readdirSync8(onboardingDir).filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3)) : [];
   return {
     project: ctx.root,
     projectId: ctx.id,
@@ -41229,7 +41418,7 @@ function docsPayload(ctx) {
   const known = new Set(m.sources.map((s) => docsTag(s.name)));
   const orphans2 = [...stats.values()].filter((s) => !known.has(s.source)).map((s) => ({ source: s.source, documents: s.documents, chunks: s.chunks }));
   return {
-    manifest: relative8(ctx.root, manifestPath(ctx)),
+    manifest: relative9(ctx.root, manifestPath(ctx)),
     sources,
     orphans: orphans2,
     totals: {
@@ -41575,7 +41764,7 @@ var init_namepath = __esm({
 });
 
 // src/code/symbols.ts
-import { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
 import { join as join27 } from "path";
 function isExported2(n) {
   if (!n.meta) return false;
@@ -41612,8 +41801,8 @@ var init_symbols2 = __esm({
 });
 
 // src/ui/graph-api.ts
-import { readFileSync as readFileSync21, realpathSync as realpathSync2, statSync as statSync9 } from "fs";
-import { relative as relative9, resolve as resolve7 } from "path";
+import { readFileSync as readFileSync21, realpathSync as realpathSync2, statSync as statSync10 } from "fs";
+import { relative as relative10, resolve as resolve7 } from "path";
 function metaOf2(row) {
   if (!row?.meta) return {};
   try {
@@ -41675,16 +41864,16 @@ function treePayload(ctx) {
 function filePayload(ctx, rel) {
   const clean = rel.replace(/^\.\//, "");
   const abs = resolve7(ctx.root, clean);
-  if (relative9(ctx.root, abs).startsWith("..")) throw new Error("path outside the project");
+  if (relative10(ctx.root, abs).startsWith("..")) throw new Error("path outside the project");
   let real = abs;
   try {
     real = realpathSync2(abs);
   } catch {
     return { error: "not found", path: clean };
   }
-  if (relative9(realpathSync2(ctx.root), real).startsWith(".."))
+  if (relative10(realpathSync2(ctx.root), real).startsWith(".."))
     throw new Error("path outside the project");
-  const st = statSync9(real);
+  const st = statSync10(real);
   if (!st.isFile()) return { error: "not a file", path: clean };
   const db = getStorage(ctx);
   const row = db.fileIndexGet(clean);
@@ -43269,6 +43458,693 @@ var init_history_api = __esm({
   }
 });
 
+// src/history/lineage.ts
+function mergedBranchName(subject) {
+  const pr = PR_MERGE.exec(subject);
+  if (pr) return { name: pr[2], pr: Number(pr[1]) };
+  const br = BRANCH_MERGE.exec(subject);
+  if (br) return { name: br[1].replace(/^origin\//, "") };
+  return void 0;
+}
+function firstParents(m, sha, stop, max) {
+  const out = [];
+  let cur = sha ? m.bySha.get(sha) : void 0;
+  while (cur && !stop.has(cur.sha) && out.length < max) {
+    out.push(cur);
+    cur = cur.parents[0] ? m.bySha.get(cur.parents[0]) : void 0;
+  }
+  return out;
+}
+function branchLineage(m, opts = {}) {
+  const max = opts.maxPerBranch ?? 500;
+  const def = m.branches.find((b) => b.isDefault && !b.remote) ?? m.branches.find((b) => b.isDefault);
+  const defaultName = def ? def.remote ? def.name.replace(/^[^/]+\//, "") : def.name : m.base ?? "main";
+  const mainline = firstParents(m, def?.sha ?? m.head, /* @__PURE__ */ new Set(), 1e5);
+  const onMain = new Set(mainline.map((c) => c.sha));
+  const byName = /* @__PURE__ */ new Map();
+  const entry = (name) => {
+    let b = byName.get(name);
+    if (!b) {
+      b = {
+        name,
+        commits: [],
+        tipAt: 0,
+        isDefault: name === defaultName,
+        live: false,
+        merged: false,
+        prs: [],
+        merges: []
+      };
+      byName.set(name, b);
+    }
+    return b;
+  };
+  const own2 = /* @__PURE__ */ new Map();
+  const add = (name, cs) => {
+    const set2 = own2.get(name) ?? /* @__PURE__ */ new Set();
+    for (const c of cs) if (!c.merge) set2.add(c.sha);
+    own2.set(name, set2);
+    const b = entry(name);
+    for (const c of cs) b.tipAt = Math.max(b.tipAt, c.at);
+  };
+  add(defaultName, mainline);
+  entry(defaultName).live = !!def;
+  for (const c of mainline) {
+    if (!c.merge || c.parents.length < 2) continue;
+    const found = mergedBranchName(c.subject);
+    const name = found?.name ?? (c.pr ? `PR #${c.pr}` : `merge ${c.short}`);
+    if (name === defaultName) continue;
+    add(name, firstParents(m, c.parents[1], onMain, max));
+    const b = entry(name);
+    b.merged = true;
+    b.merges.push(c.sha);
+    const pr = found?.pr ?? c.pr;
+    if (pr && !b.prs.includes(pr)) b.prs.push(pr);
+  }
+  const locals = new Set(m.branches.filter((b) => !b.remote).map((b) => b.name));
+  for (const ref of [...m.branches].sort((a, b) => Number(a.remote) - Number(b.remote))) {
+    if (ref.isDefault) continue;
+    const name = ref.remote ? ref.name.replace(/^[^/]+\//, "") : ref.name;
+    if (ref.remote && (locals.has(name) || name === "HEAD" || !name)) continue;
+    if (name === defaultName) continue;
+    add(name, firstParents(m, ref.sha, onMain, max));
+    const b = entry(name);
+    b.live = true;
+    b.merged ||= ref.merged;
+    if (!b.tipAt) b.tipAt = ref.at;
+  }
+  for (const [name, set2] of own2) {
+    entry(name).commits = [...set2].map((s) => m.bySha.get(s)).sort((a, b) => b.at - a.at).map((c) => c.sha);
+  }
+  const branches = [...byName.values()];
+  const ownerOf = /* @__PURE__ */ new Map();
+  for (const b of branches)
+    for (const s of b.commits) ownerOf.set(s, [...ownerOf.get(s) ?? [], b.name]);
+  return { defaultName, branches, ownerOf };
+}
+var PR_MERGE, BRANCH_MERGE;
+var init_lineage = __esm({
+  "src/history/lineage.ts"() {
+    "use strict";
+    init_esm_shims();
+    PR_MERGE = /^Merge pull request #(\d+) from [^/\s]+\/(\S+)/;
+    BRANCH_MERGE = /^Merge (?:remote-tracking )?branch '([^']+)'/;
+  }
+});
+
+// src/ui/history-graph-api.ts
+import { existsSync as existsSync24 } from "fs";
+import { join as join28 } from "path";
+function parseList(raw) {
+  if (!raw) return [];
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function metaOf3(raw) {
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function historyGraphKnowledgePayload(ctx, opts = {}) {
+  const db = getStorage(ctx);
+  const m = getHistory(ctx, db);
+  if (!m) return NO_GIT2;
+  reconcile(ctx, db);
+  try {
+    ensureDocsGraph(ctx, db);
+  } catch {
+  }
+  return buildHistoryGraph(ctx, db, m, opts);
+}
+function buildHistoryGraph(ctx, db, m, opts = {}) {
+  const nBranches = Math.max(1, Math.min(50, opts.branches ?? 8));
+  const perBranch = Math.max(1, Math.min(200, opts.commitsPerBranch ?? 25));
+  const perCommit = Math.max(1, Math.min(200, opts.filesPerCommit ?? 12));
+  const limit = Math.max(20, Math.min(2e3, opts.limit ?? 400));
+  const focus = opts.focus?.trim() || null;
+  const { defaultName, branches, ownerOf } = branchLineage(m);
+  const branchBy = new Map(branches.map((b) => [b.name, b]));
+  const memDir = `${memoriesRel(ctx)}/`;
+  const memoryOfPath = (p) => p.startsWith(memDir) && p.endsWith(".md") ? p.slice(memDir.length, -3) : void 0;
+  const memRows = new Map(
+    db.memoryList({ limit: 1e5 }).filter((r) => r.name).map((r) => [r.name, r])
+  );
+  const memFiles = /* @__PURE__ */ new Map();
+  for (const [name, row] of memRows) {
+    const paths2 = /* @__PURE__ */ new Set();
+    for (const id of parseList(row.node_ids)) {
+      const f = fileOf(id);
+      if (f) paths2.add(f);
+    }
+    if (paths2.size) memFiles.set(name, [...paths2]);
+  }
+  const nonMerge = (cs) => cs.filter((c) => !c.merge);
+  const touching = (paths2, cap) => {
+    const out = /* @__PURE__ */ new Map();
+    for (const p of paths2) for (const c of nonMerge(commitsForFile(m, p))) out.set(c.sha, c);
+    return [...out.values()].sort((a, b) => b.at - a.at).slice(0, cap);
+  };
+  const commitSet = /* @__PURE__ */ new Map();
+  const branchSet = /* @__PURE__ */ new Set();
+  let onlyFiles = null;
+  const addCommits = (cs) => {
+    for (const c of cs) commitSet.set(c.sha, c);
+  };
+  let focusId = null;
+  let followOwners = true;
+  const kind = focus ? parseId(focus).kind : null;
+  if (!focus) {
+    followOwners = false;
+    const feature = branches.filter((b) => !b.isDefault && b.commits.length).sort((a, b) => b.tipAt - a.tipAt).slice(0, nBranches);
+    for (const b of feature) {
+      branchSet.add(b.name);
+      addCommits(b.commits.slice(0, perBranch).map((s) => m.bySha.get(s)));
+    }
+    const def = branchBy.get(defaultName);
+    if (def) {
+      branchSet.add(def.name);
+      const oldest = Math.min(...feature.map((b) => b.tipAt), Date.now());
+      addCommits(
+        def.commits.map((s) => m.bySha.get(s)).filter((c, i) => i < perBranch && (feature.length < nBranches || c.at >= oldest))
+      );
+    }
+  } else if (kind === "branch") {
+    const name = focus.slice("branch:".length);
+    const b = branchBy.get(name) ?? branches.find((x) => x.name.endsWith(`/${name}`));
+    if (b) {
+      focusId = branchId(b.name);
+      branchSet.add(b.name);
+      if (b.merged) branchSet.add(defaultName);
+      addCommits(b.commits.slice(0, 150).map((s) => m.bySha.get(s)));
+    }
+    followOwners = false;
+  } else if (kind === "commit") {
+    const c = resolveCommit(m, focus.slice("commit:".length));
+    if (c) {
+      focusId = commitId(c.sha);
+      addCommits([c]);
+      addCommits([...c.origins, ...c.blamedBy].flatMap((s) => m.bySha.get(s) ?? []));
+    }
+  } else if (kind === "memory") {
+    const name = focus.slice("memory:".length);
+    focusId = memoryId(name);
+    const paths2 = memFiles.get(name) ?? [];
+    onlyFiles = new Set(paths2);
+    const own2 = `${memDir}${name}.md`;
+    addCommits([...touching(paths2, 60), ...touching([own2], 20)]);
+  } else if (kind === "doc") {
+    focusId = focus;
+    const paths2 = db.graphEdgesFrom([focus], ["documents"]).map((e) => fileOf(e.dst)).filter((p) => !!p);
+    onlyFiles = new Set(paths2);
+    addCommits(touching(paths2, 60));
+  } else {
+    const path3 = fileOf(focus) ?? focus.replace(/^file:/, "");
+    focusId = fileId(path3);
+    onlyFiles = /* @__PURE__ */ new Set([path3]);
+    addCommits(touching([path3], 60));
+  }
+  if (followOwners)
+    for (const sha of commitSet.keys())
+      for (const name of ownerOf.get(sha) ?? []) branchSet.add(name);
+  const edges = /* @__PURE__ */ new Map();
+  const addEdge = (src, dst, kind2, weight = 1) => {
+    if (src === dst) return;
+    const key = `${src}|${dst}|${kind2}`;
+    if (!edges.has(key)) edges.set(key, { src, dst, kind: kind2, weight });
+  };
+  for (const name of branchSet) {
+    const b = branchBy.get(name);
+    if (!b) continue;
+    for (const sha of b.commits)
+      if (commitSet.has(sha)) addEdge(branchId(name), commitId(sha), "contains");
+    if (b.merged && !b.isDefault && branchSet.has(defaultName))
+      addEdge(branchId(name), branchId(defaultName), "merged_into");
+  }
+  const touchCount = /* @__PURE__ */ new Map();
+  const commitFiles = /* @__PURE__ */ new Map();
+  const recorded = /* @__PURE__ */ new Map();
+  for (const c of commitSet.values()) {
+    const mems = [];
+    const paths2 = [];
+    for (const f of [...c.files].sort((a, b) => b.added + b.deleted - (a.added + a.deleted))) {
+      const mem = memoryOfPath(f.path);
+      if (mem) {
+        mems.push(mem);
+        continue;
+      }
+      if (LOCKFILE.test(f.path)) continue;
+      if (onlyFiles && !onlyFiles.has(f.path)) continue;
+      paths2.push(f.path);
+    }
+    const kept2 = paths2.slice(0, perCommit);
+    commitFiles.set(c.sha, kept2);
+    for (const p of kept2) touchCount.set(p, (touchCount.get(p) ?? 0) + 1);
+    if (mems.length) recorded.set(c.sha, mems);
+  }
+  for (const p of onlyFiles ?? []) if (!touchCount.has(p)) touchCount.set(p, 0);
+  const fileBudget = Math.max(10, limit - branchSet.size - commitSet.size - 40);
+  const files = new Set(
+    [...touchCount.entries()].sort(
+      (a, b) => Number(onlyFiles?.has(b[0]) ?? false) - Number(onlyFiles?.has(a[0]) ?? false) || b[1] - a[1] || (m.files.get(b[0])?.risk ?? 0) - (m.files.get(a[0])?.risk ?? 0) || a[0].localeCompare(b[0])
+    ).slice(0, fileBudget).map(([p]) => p)
+  );
+  for (const [sha, paths2] of commitFiles)
+    for (const p of paths2) if (files.has(p)) addEdge(commitId(sha), fileId(p), "touches");
+  const memories = /* @__PURE__ */ new Set();
+  for (const [sha, mems] of recorded)
+    for (const name of mems) {
+      memories.add(name);
+      addEdge(commitId(sha), memoryId(name), "records");
+    }
+  for (const [name, paths2] of memFiles)
+    for (const p of paths2)
+      if (files.has(p)) {
+        memories.add(name);
+        addEdge(memoryId(name), fileId(p), "mentions");
+      }
+  if (kind === "memory" && focus) memories.add(focus.slice("memory:".length));
+  const docs = /* @__PURE__ */ new Set();
+  if (files.size)
+    for (const e of db.graphEdgesTo(
+      [...files].map((p) => fileId(p)),
+      ["documents"]
+    )) {
+      docs.add(e.src);
+      addEdge(e.src, e.dst, "documents");
+    }
+  if (kind === "doc" && focus) docs.add(focus);
+  for (const l of m.links)
+    if (commitSet.has(l.fix) && commitSet.has(l.origin))
+      addEdge(commitId(l.fix), commitId(l.origin), "fixes", Math.min(3, 1 + l.lines / 20));
+  const nodes = [];
+  for (const name of branchSet) {
+    const b = branchBy.get(name);
+    if (!b) continue;
+    const id = branchId(name);
+    nodes.push({
+      id,
+      label: name,
+      kind: "branch",
+      group: "branch",
+      path: null,
+      line: null,
+      root: id === focusId,
+      at: b.tipAt,
+      commits: b.commits.length,
+      merged: b.merged,
+      live: b.live,
+      isDefault: b.isDefault,
+      prs: b.prs.length ? b.prs : void 0
+    });
+  }
+  for (const c of commitSet.values()) {
+    const id = commitId(c.sha);
+    nodes.push({
+      id,
+      label: c.subject,
+      kind: "commit",
+      group: "commit",
+      path: null,
+      line: null,
+      root: id === focusId,
+      sub: c.kind,
+      bucket: c.bucket,
+      at: c.at,
+      author: c.author,
+      short: c.short,
+      risk: c.risk
+    });
+  }
+  for (const p of files) {
+    const id = fileId(p);
+    const h = m.files.get(p);
+    nodes.push({
+      id,
+      label: p,
+      kind: "file",
+      group: "file",
+      path: p,
+      line: null,
+      root: id === focusId,
+      missing: existsSync24(join28(ctx.root, p)) ? void 0 : true,
+      risk: h?.risk,
+      fixes: h?.fixes
+    });
+  }
+  for (const name of memories) {
+    const id = memoryId(name);
+    const row = memRows.get(name);
+    nodes.push({
+      id,
+      label: name,
+      kind: "memory",
+      group: "memory",
+      path: row?.path ?? null,
+      line: null,
+      root: id === focusId,
+      missing: row ? void 0 : true,
+      sub: row?.kind,
+      status: row?.status ?? (row?.kind === "decision" ? "accepted" : void 0),
+      detail: name.includes("/") ? `${name.split("/")[0]}/` : void 0
+    });
+  }
+  const docRows = new Map(db.graphGetNodes([...docs]).map((n) => [n.id, n]));
+  for (const id of docs) {
+    const row = docRows.get(id);
+    const meta4 = metaOf3(row?.meta);
+    const cat = typeof meta4.category === "string" ? meta4.category : void 0;
+    nodes.push({
+      id,
+      label: row?.name ?? id.slice("doc:".length),
+      kind: "doc",
+      group: "doc",
+      path: row?.path ?? null,
+      line: null,
+      root: id === focusId,
+      missing: row ? void 0 : true,
+      sub: cat,
+      detail: cat ? categoryInfo(cat).label : void 0
+    });
+  }
+  if (focusId && !nodes.some((n) => n.id === focusId)) {
+    const p = parseId(focusId);
+    nodes.push({
+      id: focusId,
+      label: p.rest,
+      kind: p.kind,
+      group: ["branch", "commit", "memory", "doc"].includes(p.kind) ? p.kind : "file",
+      path: p.kind === "file" ? p.rest : null,
+      line: null,
+      root: true,
+      missing: true
+    });
+  }
+  for (const n of nodes) if (n.root) n.seed = true;
+  const deg = /* @__PURE__ */ new Map();
+  for (const e of edges.values()) {
+    deg.set(e.src, (deg.get(e.src) ?? 0) + 1);
+    deg.set(e.dst, (deg.get(e.dst) ?? 0) + 1);
+  }
+  const RANK = {
+    branch: 1,
+    commit: 2,
+    memory: 3,
+    doc: 3,
+    file: 4
+  };
+  nodes.sort(
+    (a, b) => (a.root ? 0 : RANK[a.group]) - (b.root ? 0 : RANK[b.group]) || (b.at ?? 0) - (a.at ?? 0) || (deg.get(b.id) ?? 0) - (deg.get(a.id) ?? 0) || a.id.localeCompare(b.id)
+  );
+  const total = nodes.length;
+  const kept = nodes.slice(0, limit);
+  const keep = new Set(kept.map((n) => n.id));
+  const keptEdges = [...edges.values()].filter((e) => keep.has(e.src) && keep.has(e.dst));
+  return {
+    git: true,
+    focus: focusId ?? focus,
+    defaultBranch: defaultName,
+    nodes: kept,
+    edges: keptEdges,
+    truncated: total > kept.length,
+    total,
+    /** Every branch with own commits, newest first, for the focus picker. */
+    branches: branches.filter((b) => b.commits.length).sort((a, b) => Number(b.isDefault) - Number(a.isDefault) || b.tipAt - a.tipAt).map((b) => ({
+      name: b.name,
+      commits: b.commits.length,
+      tipAt: b.tipAt,
+      merged: b.merged,
+      live: b.live,
+      isDefault: b.isDefault
+    }))
+  };
+}
+var LOCKFILE, branchId, commitId, NO_GIT2;
+var init_history_graph_api = __esm({
+  "src/ui/history-graph-api.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_category();
+    init_graph();
+    init_ids();
+    init_lineage();
+    init_model();
+    init_store();
+    init_storage();
+    LOCKFILE = /(^|\/)(package-lock\.json|npm-shrinkwrap\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|Cargo\.lock|go\.sum|poetry\.lock|uv\.lock|composer\.lock|Gemfile\.lock)$/;
+    branchId = (name) => `branch:${name}`;
+    commitId = (sha) => `commit:${sha}`;
+    NO_GIT2 = { git: false, error: "not a git repository (or no commits yet)" };
+  }
+});
+
+// src/ui/knowledge-api.ts
+function metaOf4(row) {
+  if (!row?.meta) return {};
+  try {
+    return JSON.parse(row.meta);
+  } catch {
+    return {};
+  }
+}
+function kindOfMissing(id) {
+  const k = parseId(id).kind;
+  return k === "pkg" ? "package" : k === "sym" ? "symbol" : k === "doc" ? "doc" : k;
+}
+function scopeOf2(raw) {
+  return raw === "memory" || raw === "docs" ? raw : "all";
+}
+function knowledgePayload(ctx, opts = {}) {
+  const db = getStorage(ctx);
+  reconcile(ctx, db);
+  try {
+    ensureDocsGraph(ctx, db);
+  } catch {
+  }
+  return buildKnowledge(ctx, db, opts);
+}
+function buildKnowledge(ctx, db, opts = {}) {
+  const scope = opts.scope ?? "all";
+  const limit = Math.max(10, Math.min(2e3, opts.limit ?? 300));
+  const focus = opts.focus?.trim() || null;
+  const memRows = new Map(
+    db.memoryList({ limit: 1e5 }).filter((r) => r.name).map((r) => [r.name, r])
+  );
+  const memNodes = db.graphNodesByKind(["memory"]);
+  const docNodes = db.graphNodesByKind(["doc"]);
+  const rows = /* @__PURE__ */ new Map();
+  for (const n of [...memNodes, ...docNodes]) rows.set(n.id, n);
+  const hubsOf = (id) => {
+    const n = rows.get(id);
+    if (!n) return [];
+    const m = metaOf4(n);
+    const out = [];
+    if (n.kind === "memory") {
+      const row = memRows.get(n.name);
+      const tags = row?.tags ? JSON.parse(row.tags) : m.tags ?? [];
+      for (const t of tags) out.push({ id: tagId(t), kind: "tag", label: `#${t}` });
+      if (n.name.includes("/")) {
+        const topic = n.name.split("/")[0];
+        out.push({ id: topicId(topic), kind: "topic", label: `${topic}/` });
+      }
+    } else if (n.kind === "doc") {
+      for (const t of m.tags ?? [])
+        out.push({ id: tagId(t), kind: "tag", label: `#${t}` });
+      const cat = typeof m.category === "string" ? m.category : "local";
+      out.push({ id: topicId(`docs/${cat}`), kind: "topic", label: categoryInfo(cat).label });
+    }
+    return out;
+  };
+  const scoped = [
+    ...scope !== "docs" ? memNodes : [],
+    ...scope !== "memory" ? docNodes : []
+  ].map((n) => n.id);
+  let seeds;
+  if (!focus) seeds = scoped;
+  else if (focus.startsWith("tag:") || focus.startsWith("topic:"))
+    seeds = [...memNodes, ...docNodes].map((n) => n.id).filter((id) => hubsOf(id).some((h) => h.id === focus));
+  else seeds = [focus];
+  const edges = /* @__PURE__ */ new Map();
+  const addEdge = (e) => {
+    if (e.src === e.dst) return;
+    const key = `${e.src}|${e.dst}|${e.kind}`;
+    if (!edges.has(key)) edges.set(key, e);
+  };
+  const stored = (e) => addEdge({ src: e.src, dst: e.dst, kind: e.kind, weight: e.weight });
+  const hop = (ids2) => {
+    if (!ids2.length) return [];
+    const found = /* @__PURE__ */ new Set();
+    for (const e of db.graphEdgesFrom(ids2, ALL_KINDS)) {
+      stored(e);
+      found.add(e.dst);
+    }
+    for (const e of db.graphEdgesTo(ids2, ALL_KINDS)) {
+      stored(e);
+      found.add(e.src);
+    }
+    return [...found];
+  };
+  const first = hop(seeds);
+  if (focus && !focus.startsWith("tag:") && !focus.startsWith("topic:")) {
+    const fresh = first.filter((id) => !seeds.includes(id));
+    hop(fresh);
+  }
+  const pages = localDocPages(ctx, db);
+  const knowledgeIds = () => new Set([...edges.values()].flatMap((e) => [e.src, e.dst]).concat(seeds));
+  if (pages.size) {
+    for (const id of knowledgeIds()) {
+      if (!id.startsWith("memory:")) continue;
+      const row = memRows.get(id.slice("memory:".length));
+      const related = row?.node_ids ? JSON.parse(row.node_ids) : [];
+      for (const r of related) {
+        const f = fileOf(r);
+        for (const name of f && pages.get(f) || [])
+          addEdge({ src: id, dst: docId(name), kind: "about", weight: 1, derived: true });
+      }
+    }
+    const docsInView = [...knowledgeIds()].filter((id) => id.startsWith("doc:"));
+    if (docsInView.length) {
+      for (const [name, row] of memRows) {
+        const related = row.node_ids ? JSON.parse(row.node_ids) : [];
+        for (const r of related) {
+          const f = fileOf(r);
+          for (const doc of f && pages.get(f) || [])
+            if (docsInView.includes(docId(doc)))
+              addEdge({
+                src: memoryId(name),
+                dst: docId(doc),
+                kind: "about",
+                weight: 1,
+                derived: true
+              });
+        }
+      }
+    }
+  }
+  const hubNodes = /* @__PURE__ */ new Map();
+  for (const id of knowledgeIds()) {
+    for (const h of hubsOf(id)) {
+      if (!hubNodes.has(h.id))
+        hubNodes.set(h.id, {
+          id: h.id,
+          label: h.label,
+          kind: h.kind,
+          path: null,
+          line: null,
+          group: "hub"
+        });
+      addEdge({
+        src: id,
+        dst: h.id,
+        kind: h.kind === "tag" ? "tagged" : "in_topic",
+        weight: 0.5,
+        derived: true
+      });
+    }
+  }
+  if (focus && (focus.startsWith("tag:") || focus.startsWith("topic:")) && !hubNodes.has(focus))
+    hubNodes.set(focus, {
+      id: focus,
+      label: focus.startsWith("tag:") ? `#${focus.slice(4)}` : `${focus.slice(6)}/`,
+      kind: focus.startsWith("tag:") ? "tag" : "topic",
+      path: null,
+      line: null,
+      group: "hub"
+    });
+  const ids = knowledgeIds();
+  for (const h of hubNodes.keys()) ids.add(h);
+  const graphRows = new Map(
+    db.graphGetNodes([...ids].filter((id) => !hubNodes.has(id))).map((n) => [n.id, n])
+  );
+  const seedSet = new Set(seeds);
+  if (focus) seedSet.add(focus);
+  const nodes = [];
+  for (const id of ids) {
+    const hub = hubNodes.get(id);
+    if (hub) {
+      nodes.push({ ...hub, seed: seedSet.has(id) || void 0, root: id === focus });
+      continue;
+    }
+    const row = graphRows.get(id);
+    const base = vis(row, id, id === focus);
+    const m = metaOf4(row);
+    const node2 = {
+      ...base,
+      kind: row ? row.kind : kindOfMissing(id),
+      group: "code",
+      seed: seedSet.has(id) || void 0,
+      missing: row ? void 0 : true
+    };
+    if (node2.kind === "memory") {
+      const name = row?.name ?? id.slice("memory:".length);
+      const mr = memRows.get(name);
+      node2.group = "memory";
+      node2.label = name;
+      node2.sub = mr?.kind ?? m.kind;
+      node2.status = mr?.status ?? m.status ?? (node2.sub === "decision" ? "accepted" : void 0);
+      node2.tags = mr?.tags ? JSON.parse(mr.tags) : m.tags;
+      node2.detail = name.includes("/") ? `${name.split("/")[0]}/` : void 0;
+    } else if (node2.kind === "doc") {
+      node2.group = "doc";
+      node2.label = row?.name ?? id.slice("doc:".length);
+      node2.sub = typeof m.category === "string" ? m.category : void 0;
+      node2.detail = node2.sub ? categoryInfo(node2.sub).label : void 0;
+      node2.provider = typeof m.provider === "string" ? m.provider : void 0;
+      node2.tags = m.tags;
+    }
+    nodes.push(node2);
+  }
+  const deg = /* @__PURE__ */ new Map();
+  for (const e of edges.values()) {
+    deg.set(e.src, (deg.get(e.src) ?? 0) + 1);
+    deg.set(e.dst, (deg.get(e.dst) ?? 0) + 1);
+  }
+  const updated = (n) => n.kind === "memory" ? memRows.get(n.label)?.updated_at ?? 0 : 0;
+  const rank = (n) => n.root ? 0 : n.seed ? 1 : n.group === "memory" || n.group === "doc" ? 2 : n.group === "hub" ? 3 : 4;
+  nodes.sort(
+    (a, b) => rank(a) - rank(b) || updated(b) - updated(a) || (deg.get(b.id) ?? 0) - (deg.get(a.id) ?? 0) || a.id.localeCompare(b.id)
+  );
+  const total = nodes.length;
+  const kept = nodes.slice(0, limit);
+  const keep = new Set(kept.map((n) => n.id));
+  const keptEdges = [...edges.values()].filter((e) => keep.has(e.src) && keep.has(e.dst));
+  const counts = { nodes: {}, edges: {} };
+  for (const n of kept) counts.nodes[n.kind] = (counts.nodes[n.kind] ?? 0) + 1;
+  for (const e of keptEdges) counts.edges[e.kind] = (counts.edges[e.kind] ?? 0) + 1;
+  return {
+    scope,
+    focus,
+    nodes: kept,
+    edges: keptEdges,
+    truncated: total > kept.length,
+    total,
+    counts
+  };
+}
+var KNOWLEDGE_EDGES, ALL_KINDS, tagId, topicId;
+var init_knowledge_api = __esm({
+  "src/ui/knowledge-api.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_category();
+    init_graph();
+    init_ids();
+    init_store();
+    init_storage();
+    init_graph_api();
+    KNOWLEDGE_EDGES = ["mentions", "links", "supersedes", "documents"];
+    ALL_KINDS = [...KNOWLEDGE_EDGES];
+    tagId = (t) => `tag:${t}`;
+    topicId = (t) => `topic:${t}`;
+  }
+});
+
 // src/ui/server.ts
 var server_exports = {};
 __export(server_exports, {
@@ -43276,9 +44152,9 @@ __export(server_exports, {
   uiDir: () => uiDir
 });
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync23, readFileSync as readFileSync22, statSync as statSync10 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync22, statSync as statSync11 } from "fs";
 import { createServer } from "http";
-import { extname as extname3, join as join28, normalize as normalize6 } from "path";
+import { extname as extname3, join as join29, normalize as normalize6 } from "path";
 import { URL as URL2 } from "url";
 function json2(res, status, body) {
   res.writeHead(status, {
@@ -43300,7 +44176,7 @@ function strList(v) {
   return void 0;
 }
 function uiDir() {
-  return process.env.EMINIAR_UI_DIR || join28(pluginRoot(), "dist", "ui");
+  return process.env.EMINIAR_UI_DIR || join29(pluginRoot(), "dist", "ui");
 }
 function originAllowed(req, port) {
   const host = req.headers.host ?? "";
@@ -43324,14 +44200,14 @@ function originAllowed(req, port) {
 function serveStatic(res, p) {
   const dir = uiDir();
   const rel = p === "/" ? "index.html" : p.replace(/^\/+/, "");
-  const file3 = normalize6(join28(dir, rel));
+  const file3 = normalize6(join29(dir, rel));
   if (!file3.startsWith(normalize6(dir))) return false;
-  if (!existsSync23(file3) || !statSync10(file3).isFile()) return false;
+  if (!existsSync25(file3) || !statSync11(file3).isFile()) return false;
   const type = MIME[extname3(file3).toLowerCase()] ?? "application/octet-stream";
   if (rel === "index.html") {
     const stamp = (name) => {
       try {
-        return `/${name}?v=${Math.floor(statSync10(join28(dir, name)).mtimeMs)}`;
+        return `/${name}?v=${Math.floor(statSync11(join29(dir, name)).mtimeMs)}`;
       } catch {
         return `/${name}`;
       }
@@ -43495,6 +44371,16 @@ async function serve(opts) {
         if (!provider) return json2(res, 400, { error: "provider required" });
         return json2(res, 200, await docsResolvePayload(ctx(), provider));
       }
+      if (p === "/api/knowledge")
+        return json2(
+          res,
+          200,
+          knowledgePayload(ctx(), {
+            scope: scopeOf2(q.get("scope")),
+            focus: str2("focus"),
+            limit: num2("limit", 300)
+          })
+        );
       if (p === "/api/graph") {
         const mode = q.get("mode") ?? "impact";
         const node2 = q.get("node") ?? "";
@@ -43651,6 +44537,18 @@ async function serve(opts) {
       }
       if (p === "/api/history/graph")
         return json2(res, 200, historyGraphPayload(ctx(), num2("limit", 150)));
+      if (p === "/api/history/knowledge")
+        return json2(
+          res,
+          200,
+          historyGraphKnowledgePayload(ctx(), {
+            focus: str2("focus"),
+            branches: num2("branches", 8),
+            commitsPerBranch: num2("commits", 25),
+            filesPerCommit: num2("files", 12),
+            limit: num2("limit", 400)
+          })
+        );
       if (p === "/api/history/risk")
         return json2(res, 200, historyRiskPayload(ctx(), strList(q.get("paths"))));
       if (p === "/api/history/symbol") {
@@ -43705,6 +44603,8 @@ var init_server = __esm({
     init_api2();
     init_graph_api();
     init_history_api();
+    init_history_graph_api();
+    init_knowledge_api();
     MIME = {
       ".html": "text/html; charset=utf-8",
       ".js": "text/javascript; charset=utf-8",
@@ -43727,7 +44627,7 @@ var statusline_exports = {};
 __export(statusline_exports, {
   renderStatusline: () => renderStatusline
 });
-import { existsSync as existsSync24, readFileSync as readFileSync23, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync23, writeFileSync as writeFileSync9 } from "fs";
 function renderStatusline(raw) {
   let input2 = {};
   try {
@@ -43736,7 +44636,7 @@ function renderStatusline(raw) {
   }
   const cache3 = paths().statuslineCache;
   try {
-    if (existsSync24(cache3)) {
+    if (existsSync26(cache3)) {
       const c = JSON.parse(readFileSync23(cache3, "utf8"));
       if (Date.now() - c.at < 5e3 && c.key === (input2.session_id ?? "")) return c.line;
     }