@anokye-labs/kbexplorer-engine 0.1.0

package/dist/index.js

@@ -0,0 +1,2892 @@
+export { buildManifest, globToRegex } from './chunk-MW4BLXVK.js';
+import { resolveGraphStoreOptions } from './chunk-BA526FDQ.js';
+export { OrgChartProvider, WikipediaProvider, loadExternalProviders } from './chunk-ASLGNOYV.js';
+import { loadNodeMap } from './chunk-XVI6CBSX.js';
+export { DEFAULT_STRUCTURED_CONTENT_PATH, extractImportPaths, hasExplicitStructuredContentPath, loadNodeMap, normalizeRepoRelativeDir, resolveImportPath, resolveStructuredContentPath } from './chunk-XVI6CBSX.js';
+import { DEFAULT_TRANSFORMS, registerType, buildGraph, applyTransforms } from './chunk-DJ2DBEEK.js';
+export { DEFAULT_TRANSFORMS, EDGE_TYPE_WEIGHTS, MAX_VISIBLE_EDGES, MAX_VISIBLE_NODES, applyTransforms, buildGraph, getEdgeDescription, getEdgeWeight, getHubNodeId, getNodeDegrees, getRegisteredTypes, hasType, issueDirectoryLinkTransform, issueSplitTransform, readmeTransform, registerBuiltInNodeTypes, registerType, resetNodeTypeRegistry, resolveNodeLayer, resolveType, resolveTypeCluster, trimGraphToLimits } from './chunk-DJ2DBEEK.js';
+import { parseMarkdownFile, renderSafeMarkdown, treeToNodes, issueToNode, extractIssueRefs, extractClusters } from './chunk-FJ4GTN4U.js';
+export { DEFAULT_CONFIG, extractClusters, extractIssueRefs, fetchCommits, fetchFile, fetchFiles, fetchIssues, fetchPullRequests, fetchReleases, fetchTree, filterAccessWithheld, isAccessWithheld, issueToNode, loadAuthoredContent, loadConfig, loadRepoContent, parseAccessLabel, parseMarkdownFile, renderSafeMarkdown, splitIntoSections, treeToNodes } from './chunk-FJ4GTN4U.js';
+import { assignIdentity, urnIdentity } from './chunk-JNQVSNLC.js';
+export { assignIdentity, buildIdentityIndex, shareIdentity, urnBody, urnIdentity } from './chunk-JNQVSNLC.js';
+import { buildProviderResultCacheKey } from './chunk-HXAS3BSD.js';
+import yaml from 'yaml';
+import { stripScheme, buildPersonAddress, buildJsonLd } from '@anokye-labs/kbexplorer-core';
+import { ingestRichMarkdown } from '@anokye-labs/kbexplorer-provider-rich-markdown/lib';
+
+// src/query.ts
+function getNode(graph, id) {
+  return graph.nodes.find((n) => n.id === id);
+}
+function findNodes(graph, predicate) {
+  return graph.nodes.filter(predicate);
+}
+function edgeTypeMatcher(edgeType) {
+  if (edgeType === void 0) return () => true;
+  const set = new Set(Array.isArray(edgeType) ? edgeType : [edgeType]);
+  return (type) => set.has(type);
+}
+function neighbors(graph, id, options = {}) {
+  const direction = options.direction ?? "both";
+  const matchesType = edgeTypeMatcher(options.edgeType);
+  const nodeById = indexNodes(graph);
+  if (!nodeById.has(id)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const consider = (neighborId) => {
+    if (neighborId === id || seen.has(neighborId)) return;
+    const node = nodeById.get(neighborId);
+    if (!node) return;
+    seen.add(neighborId);
+    out.push(node);
+  };
+  for (const edge of graph.edges) {
+    if (!matchesType(edge.type)) continue;
+    if ((direction === "out" || direction === "both") && edge.from === id) consider(edge.to);
+    if ((direction === "in" || direction === "both") && edge.to === id) consider(edge.from);
+  }
+  return out;
+}
+function related(graph, id) {
+  const nodeById = indexNodes(graph);
+  const relatedIds = graph.related[id] ?? [];
+  const out = [];
+  for (const relatedId of relatedIds) {
+    const node = nodeById.get(relatedId);
+    if (node) out.push(node);
+  }
+  return out;
+}
+function subgraph(graph, seeds, options = {}) {
+  const radius = options.radius ?? 1;
+  const direction = options.direction ?? "both";
+  const nodeById = indexNodes(graph);
+  const adjacency = buildAdjacency(graph.edges, direction);
+  const kept = /* @__PURE__ */ new Set();
+  let frontier = [];
+  for (const seed of Array.isArray(seeds) ? seeds : [seeds]) {
+    if (nodeById.has(seed) && !kept.has(seed)) {
+      kept.add(seed);
+      frontier.push(seed);
+    }
+  }
+  for (let hop = 0; hop < radius && frontier.length > 0; hop++) {
+    const next = [];
+    for (const current of frontier) {
+      for (const neighborId of adjacency.get(current) ?? []) {
+        if (!kept.has(neighborId)) {
+          kept.add(neighborId);
+          next.push(neighborId);
+        }
+      }
+    }
+    frontier = next;
+  }
+  const nodes = graph.nodes.filter((n) => kept.has(n.id));
+  const edges = graph.edges.filter((e) => kept.has(e.from) && kept.has(e.to));
+  const usedClusters = new Set(nodes.map((n) => n.cluster));
+  const clusters = graph.clusters.filter((c) => usedClusters.has(c.id));
+  const relatedOut = {};
+  for (const node of nodes) {
+    const filtered = (graph.related[node.id] ?? []).filter((rid) => kept.has(rid));
+    if (filtered.length > 0) relatedOut[node.id] = filtered;
+  }
+  return { nodes, edges, clusters, related: relatedOut };
+}
+function shortestPath(graph, from, to, options = {}) {
+  const direction = options.direction ?? "both";
+  const nodeById = indexNodes(graph);
+  if (!nodeById.has(from) || !nodeById.has(to)) return null;
+  if (from === to) return [from];
+  const adjacency = buildAdjacency(graph.edges, direction);
+  const previous = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set([from]);
+  const queue = [from];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const neighborId of adjacency.get(current) ?? []) {
+      if (visited.has(neighborId)) continue;
+      visited.add(neighborId);
+      previous.set(neighborId, current);
+      if (neighborId === to) {
+        return reconstructPath(previous, from, to);
+      }
+      queue.push(neighborId);
+    }
+  }
+  return null;
+}
+function indexNodes(graph) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) byId.set(node.id, node);
+  return byId;
+}
+function buildAdjacency(edges, direction) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const link = (a, b) => {
+    let set = adjacency.get(a);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      adjacency.set(a, set);
+    }
+    set.add(b);
+  };
+  for (const edge of edges) {
+    if (direction === "out" || direction === "both") link(edge.from, edge.to);
+    if (direction === "in" || direction === "both") link(edge.to, edge.from);
+  }
+  return adjacency;
+}
+function reconstructPath(previous, from, to) {
+  const path = [to];
+  let cursor = to;
+  while (cursor !== from) {
+    const prev = previous.get(cursor);
+    if (prev === void 0) return [];
+    path.push(prev);
+    cursor = prev;
+  }
+  path.reverse();
+  return path;
+}
+function globToRegex2(pattern) {
+  let re = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*" && pattern[i + 1] === "*") {
+      re += ".*";
+      i += 1;
+      if (pattern[i + 1] === "/") i += 1;
+    } else if (c === "*") {
+      re += "[^/]*";
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if (".+^${}()|[]\\".includes(c)) {
+      re += "\\" + c;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+function matchesAnyGlob(path, globs) {
+  if (globs === void 0) return true;
+  const list = Array.isArray(globs) ? globs : [globs];
+  return list.some((g) => globToRegex2(g).test(path));
+}
+function fileName(path) {
+  return path.split("/").pop() ?? path;
+}
+function baseName(path) {
+  const name = fileName(path);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.substring(0, dot) : name;
+}
+function extOf(path) {
+  const name = fileName(path);
+  const dot = name.lastIndexOf(".");
+  return dot >= 0 ? name.substring(dot + 1).toLowerCase() : "";
+}
+function slugify(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function getByPath(obj, path) {
+  let cur = obj;
+  for (const key2 of path.split(".")) {
+    if (cur == null || typeof cur !== "object") return void 0;
+    cur = cur[key2];
+  }
+  return cur;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseStructuredContent(file) {
+  const ext = extOf(file.path);
+  const raw = file.content;
+  if (!raw || !raw.trim()) return null;
+  const tryParse = (format) => {
+    try {
+      const parsed = format === "json" ? JSON.parse(raw) : yaml.parse(raw);
+      if (isPlainObject(parsed) || Array.isArray(parsed)) {
+        return { format, data: parsed };
+      }
+    } catch {
+    }
+    return null;
+  };
+  if (ext === "json" || ext === "jsonld") return tryParse("json");
+  if (ext === "yml" || ext === "yaml") return tryParse("yaml");
+  return tryParse("yaml");
+}
+function matchRule(file, data, map) {
+  for (const rule of map.rules ?? []) {
+    if (!matchesAnyGlob(file.path, rule.glob)) continue;
+    if (rule.shape?.length) {
+      if (!isPlainObject(data)) continue;
+      const hasAll = rule.shape.every((k) => k in data);
+      if (!hasAll) continue;
+    }
+    return rule;
+  }
+  return void 0;
+}
+function deriveId(file, options) {
+  if (options?.id) return options.id;
+  const prefix = options?.idPrefix ?? "cfg";
+  return `${prefix}-${slugify(file.path)}`;
+}
+function structuredSource(entityType, ref) {
+  return { type: "structured", entityType, ref };
+}
+function makeNode(args) {
+  const identity = urnIdentity("structured", args.ref);
+  const dataBag = isPlainObject(args.data) ? args.data : { items: args.data };
+  return {
+    id: args.id,
+    title: args.title,
+    cluster: args.cluster,
+    content: "",
+    rawContent: "",
+    emoji: args.emoji,
+    display: "entity",
+    connections: (args.edges ?? []).map((e) => ({
+      to: e.to,
+      description: e.description ?? "Structural",
+      source: "inferred",
+      ...e.type !== void 0 ? { type: e.type } : {},
+      ...e.relation !== void 0 ? { relation: e.relation } : {}
+    })),
+    identity,
+    derived: true,
+    source: structuredSource(args.entityType, args.ref),
+    entityType: args.entityType,
+    data: dataBag,
+    jsonld: buildJsonLd({ id: args.id, identity }, args.ldType, args.ldProps ?? {})
+  };
+}
+function titleFromData(data, rule, file) {
+  if (rule?.titleFrom) {
+    const v = getByPath(data, rule.titleFrom);
+    if (typeof v === "string" && v.trim()) return v;
+  }
+  if (isPlainObject(data)) {
+    const name = data.name ?? data.title;
+    if (typeof name === "string" && name.trim()) return name;
+  }
+  return baseName(file.path);
+}
+function buildMappedNode(file, data, rule, options) {
+  const entityType = rule.entityType ?? slugify(rule.type);
+  const ldProps = {};
+  if (rule.fields) {
+    for (const [out, src] of Object.entries(rule.fields)) {
+      const v = getByPath(data, src);
+      if (v !== void 0) ldProps[out] = v;
+    }
+  }
+  return makeNode({
+    id: deriveId(file, options),
+    title: titleFromData(data, rule, file),
+    cluster: rule.cluster ?? options?.cluster ?? "infra",
+    emoji: rule.emoji ?? "DocumentData",
+    entityType,
+    ldType: rule.type,
+    data,
+    ref: file.path,
+    ldProps,
+    ...rule.edges !== void 0 ? { edges: rule.edges } : {}
+  });
+}
+function inferType(data) {
+  if (isPlainObject(data)) {
+    const has = (k) => k in data;
+    if (has("on") && has("jobs")) return { ldType: "Workflow", entityType: "workflow", emoji: "Flow" };
+    if (has("runs")) return { ldType: "SoftwareApplication", entityType: "github-action", emoji: "PuzzlePiece" };
+    if (has("version") && has("updates")) return { ldType: "DependabotConfig", entityType: "dependabot-config", emoji: "ArrowSync" };
+    if (has("inputs") || has("outputs")) return { ldType: "ParameterisedConfig", entityType: "structured-config", emoji: "Options" };
+  }
+  return { ldType: "StructuredConfig", entityType: "structured-config", emoji: "DocumentData" };
+}
+function inferStructuredNode(file, parsed, options) {
+  const result = parsed ?? parseStructuredContent(file);
+  if (!result) return null;
+  const { ldType, entityType, emoji } = inferType(result.data);
+  return makeNode({
+    id: deriveId(file, options),
+    title: titleFromData(result.data, void 0, file),
+    cluster: options?.cluster ?? "infra",
+    emoji,
+    entityType,
+    ldType,
+    data: result.data,
+    ref: file.path
+  });
+}
+function applyStructuredNodeMap(file, map, options) {
+  const parsed = parseStructuredContent(file);
+  if (!parsed) return null;
+  const rule = map ? matchRule(file, parsed.data, map) : void 0;
+  if (rule) return buildMappedNode(file, parsed.data, rule, options);
+  return inferStructuredNode(file, parsed, options);
+}
+function parseStructuredNodeMap(raw) {
+  if (!raw || !raw.trim()) return { rules: [] };
+  try {
+    const parsed = yaml.parse(raw);
+    const rules = Array.isArray(parsed?.rules) ? parsed.rules.filter((r) => r && typeof r.type === "string") : [];
+    return { rules };
+  } catch {
+    return { rules: [] };
+  }
+}
+function reconstructSource(node, formatOverride) {
+  const data = node.data ?? {};
+  let format = formatOverride ?? "yaml";
+  if (!formatOverride && node.source.type === "structured" && node.source.ref) {
+    const ext = extOf(node.source.ref);
+    if (ext === "json" || ext === "jsonld") format = "json";
+  }
+  const payload = isPlainObject(data) && Object.keys(data).length === 1 && Array.isArray(data.items) ? data.items : data;
+  return format === "json" ? JSON.stringify(payload, null, 2) : yaml.stringify(payload);
+}
+function repoCoordsFromConfig(config) {
+  const { owner, repo, branch } = config.source;
+  return { owner, repo, branch: branch && branch.trim() ? branch : "main" };
+}
+function canEditSource(node) {
+  const f = node.sourceFile;
+  return !!f && typeof f.path === "string" && f.path.trim().length > 0 && typeof f.raw === "string" && // Validate the runtime `format` too: cached/loaded data could carry a
+  // missing or unknown format, which would later crash the editor
+  // (`format.toUpperCase()`) or mis-dispatch validation. An invalid shape
+  // simply exposes no affordance — a safe no-op.
+  (f.format === "yaml" || f.format === "json");
+}
+function resolveSourceFile(node) {
+  return canEditSource(node) ? node.sourceFile : null;
+}
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function validateSourceContent(raw, format) {
+  if (raw.trim().length === 0) {
+    return { ok: false, error: "Source file is empty." };
+  }
+  try {
+    if (format === "json") {
+      JSON.parse(raw);
+    } else if (format === "yaml") {
+      yaml.parse(raw);
+    }
+    return { ok: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+var GITHUB_WEB = "https://github.com";
+function encodeRepoPath(path) {
+  return path.split("/").filter((seg) => seg.length > 0).map((seg) => encodeURIComponent(seg)).join("/");
+}
+function buildEditUrl(coords, path) {
+  const { owner, repo, branch } = coords;
+  return `${GITHUB_WEB}/${owner}/${repo}/edit/${encodeURIComponent(branch)}/${encodeRepoPath(path)}`;
+}
+function buildNewFileUrl(coords, path, content) {
+  const { owner, repo, branch } = coords;
+  const params = new URLSearchParams({ filename: path, value: content });
+  return `${GITHUB_WEB}/${owner}/${repo}/new/${encodeURIComponent(branch)}?${params.toString()}`;
+}
+function buildHandoffUrl(coords, path, content, exists) {
+  return exists ? buildEditUrl(coords, path) : buildNewFileUrl(coords, path, content);
+}
+function splitLines(text) {
+  const lines = text.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+var MAX_DIFF_LINES = 5e3;
+function diffLines(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m > MAX_DIFF_LINES || n > MAX_DIFF_LINES) {
+    const coarse = [];
+    for (const line of a) coarse.push({ type: "-", line });
+    for (const line of b) coarse.push({ type: "+", line });
+    return coarse;
+  }
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = m - 1; i2 >= 0; i2--) {
+    for (let j2 = n - 1; j2 >= 0; j2--) {
+      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < m && j < n) {
+    if (a[i] === b[j]) {
+      ops.push({ type: " ", line: a[i] });
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      ops.push({ type: "-", line: a[i] });
+      i++;
+    } else {
+      ops.push({ type: "+", line: b[j] });
+      j++;
+    }
+  }
+  while (i < m) ops.push({ type: "-", line: a[i++] });
+  while (j < n) ops.push({ type: "+", line: b[j++] });
+  return ops;
+}
+function buildUnifiedDiff(path, oldText, newText, context = 3, isNew = false) {
+  if (oldText === newText) return "";
+  const a = splitLines(oldText);
+  const b = splitLines(newText);
+  const ops = diffLines(a, b);
+  const n = ops.length;
+  const oldAt = new Array(n);
+  const newAt = new Array(n);
+  let oldNo = 1;
+  let newNo = 1;
+  for (let k = 0; k < n; k++) {
+    oldAt[k] = oldNo;
+    newAt[k] = newNo;
+    if (ops[k].type === " ") {
+      oldNo++;
+      newNo++;
+    } else if (ops[k].type === "-") {
+      oldNo++;
+    } else {
+      newNo++;
+    }
+  }
+  const ranges = [];
+  let i = 0;
+  while (i < n) {
+    if (ops[i].type === " ") {
+      i++;
+      continue;
+    }
+    let end = i + 1;
+    let gap = 0;
+    let j = i + 1;
+    while (j < n) {
+      if (ops[j].type !== " ") {
+        end = j + 1;
+        gap = 0;
+      } else {
+        gap++;
+        if (gap > 2 * context) break;
+      }
+      j++;
+    }
+    ranges.push([Math.max(0, i - context), Math.min(n, end + context)]);
+    i = j;
+  }
+  const merged = [];
+  for (const r of ranges) {
+    const last = merged[merged.length - 1];
+    if (last && r[0] <= last[1]) last[1] = Math.max(last[1], r[1]);
+    else merged.push([r[0], r[1]]);
+  }
+  const hunks = [];
+  for (const [s, e] of merged) {
+    let oldCount = 0;
+    let newCount = 0;
+    const body = [];
+    for (let k = s; k < e; k++) {
+      const o = ops[k];
+      if (o.type === " ") {
+        oldCount++;
+        newCount++;
+        body.push(` ${o.line}`);
+      } else if (o.type === "-") {
+        oldCount++;
+        body.push(`-${o.line}`);
+      } else {
+        newCount++;
+        body.push(`+${o.line}`);
+      }
+    }
+    const oldStart = oldCount === 0 ? oldAt[s] - 1 : oldAt[s];
+    const newStart = newCount === 0 ? newAt[s] - 1 : newAt[s];
+    hunks.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@
+${body.join("\n")}`);
+  }
+  const fromPath = isNew ? "/dev/null" : `a/${path}`;
+  const newFileLine = isNew ? "new file mode 100644\n" : "";
+  const header = `diff --git a/${path} b/${path}
+${newFileLine}--- ${fromPath}
++++ b/${path}
+`;
+  return `${header}${hunks.join("\n")}
+`;
+}
+function patchFilename(path) {
+  const base = path.split("/").filter(Boolean).pop() ?? "source";
+  return `${base}.patch`;
+}
+function buildSourceEditHandoff(coords, file, newContent, exists = true) {
+  const base = normalizeNewlines(file.raw);
+  const next = normalizeNewlines(newContent);
+  return {
+    changed: next !== base,
+    exists,
+    url: buildHandoffUrl(coords, file.path, next, exists),
+    editUrl: buildEditUrl(coords, file.path),
+    newFileUrl: buildNewFileUrl(coords, file.path, next),
+    patch: buildUnifiedDiff(file.path, base, next, 3, !exists),
+    patchName: patchFilename(file.path)
+  };
+}
+
+// src/providers.ts
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  register(provider) {
+    this.providers.set(provider.id, provider);
+  }
+  /** Get providers in dependency-safe execution order */
+  getExecutionOrder() {
+    const visited = /* @__PURE__ */ new Set();
+    const order = [];
+    const visit = (id) => {
+      if (visited.has(id)) return;
+      visited.add(id);
+      const p = this.providers.get(id);
+      if (!p) return;
+      for (const dep of p.dependencies ?? []) visit(dep);
+      order.push(p);
+    };
+    for (const id of this.providers.keys()) visit(id);
+    return order;
+  }
+  get(id) {
+    return this.providers.get(id);
+  }
+};
+
+// src/providers/rich-markdown/detect.ts
+var FRONTMATTER_RE = /^\uFEFF?---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+var DISPLAY_RE = /^\s*display\s*:\s*(?:"([^"]*)"|'([^']*)'|([^\s#]+))/m;
+function readFrontmatterDisplay(raw) {
+  const fm = FRONTMATTER_RE.exec(raw);
+  if (!fm) return void 0;
+  const m = DISPLAY_RE.exec(fm[1] ?? "");
+  if (!m) return void 0;
+  const value = (m[1] ?? m[2] ?? m[3] ?? "").trim();
+  return value || void 0;
+}
+function isRichAuthoredMarkdown(raw) {
+  return readFrontmatterDisplay(raw) === "rich-markdown";
+}
+
+// src/providers/authored-provider.ts
+var AuthoredProvider = class {
+  id = "authored";
+  name = "Authored Content";
+  dependencies = [];
+  authoredContent;
+  nodemapRaw;
+  nodemapFiles;
+  nodemapDirs;
+  listFiles;
+  constructor(authoredContent, nodemapRaw, nodemapFiles, nodemapDirs, listFiles) {
+    this.authoredContent = authoredContent;
+    this.nodemapRaw = nodemapRaw;
+    this.nodemapFiles = nodemapFiles;
+    this.nodemapDirs = nodemapDirs;
+    this.listFiles = listFiles;
+  }
+  async resolve(_config, _existingNodes) {
+    const nodes = [];
+    for (const [path, raw] of Object.entries(this.authoredContent)) {
+      if (isRichAuthoredMarkdown(raw)) continue;
+      try {
+        const node = parseMarkdownFile(path, raw);
+        node.provider = "authored";
+        if (!node.identity) {
+          node.identity = `urn:content:${node.id}`;
+        }
+        nodes.push(node);
+      } catch {
+        console.warn(`[AuthoredProvider] Failed to parse ${path}, skipping`);
+      }
+    }
+    if (this.nodemapRaw) {
+      const readFile = async (path) => this.nodemapFiles?.[path] ?? null;
+      const listDirectory = this.nodemapDirs ? async (dir) => this.nodemapDirs[dir] ?? [] : void 0;
+      const nodemapNodes = await loadNodeMap(
+        this.nodemapRaw,
+        readFile,
+        this.listFiles,
+        listDirectory
+      );
+      for (const node of nodemapNodes) {
+        node.provider = "authored";
+        if (!node.identity) {
+          node.identity = assignIdentity(node) ?? `urn:content:${node.id}`;
+        }
+        nodes.push(node);
+      }
+    }
+    return { nodes, edges: [] };
+  }
+};
+var PROVIDER_ID = "authored-rich-markdown";
+var LEADING_FRONTMATTER_RE = /^\uFEFF?---\r?\n[\s\S]*?\r?\n---\r?\n?/;
+function stripLeadingFrontmatter(raw) {
+  return raw.replace(LEADING_FRONTMATTER_RE, "");
+}
+function toTemplateBlock(block) {
+  const out = { kind: block.lang, source: block.content };
+  if (typeof block.contentHash === "string") out.hash = block.contentHash;
+  if (block.span && Number.isFinite(block.span.start) && Number.isFinite(block.span.end)) {
+    out.range = { start: block.span.start, end: block.span.end };
+  }
+  return out;
+}
+function localIdOf(ingested) {
+  return ingested.id === ingested.identity ? stripScheme(ingested.id) : ingested.id;
+}
+function adaptIngestedNode(ingested) {
+  const { richMarkdown: pkgRichMarkdown, ...frontmatter } = ingested.data;
+  const blocks = (pkgRichMarkdown.blocks ?? []).map(toTemplateBlock);
+  const fmCluster = typeof frontmatter.cluster === "string" ? frontmatter.cluster.trim() : "";
+  const cluster = fmCluster || ingested.cluster;
+  const body = stripLeadingFrontmatter(ingested.rawContent);
+  const node = {
+    id: localIdOf(ingested),
+    title: ingested.title,
+    cluster,
+    // The pure lib leaves `content` empty; render the body exactly as the engine
+    // renders any node so ProseContent finds the same fences at runtime.
+    content: renderSafeMarkdown(body),
+    rawContent: body,
+    display: "rich-markdown",
+    connections: ingested.connections ?? [],
+    source: ingested.source,
+    provider: PROVIDER_ID,
+    data: {
+      ...frontmatter,
+      richMarkdown: { frontmatter, blocks }
+    }
+  };
+  const identity = assignIdentity(node);
+  if (identity !== void 0) node.identity = identity;
+  if (ingested.emoji != null) node.emoji = ingested.emoji;
+  if (ingested.parent != null) node.parent = ingested.parent;
+  if (ingested.entityType != null) node.entityType = ingested.entityType;
+  if (ingested.jsonld != null) {
+    node.jsonld = {
+      ...ingested.jsonld,
+      "@id": node.identity ?? node.id
+    };
+  }
+  if (ingested.sourceFile != null) node.sourceFile = ingested.sourceFile;
+  return node;
+}
+var AuthoredRichMarkdownProvider = class {
+  id = PROVIDER_ID;
+  name = "Authored Rich-Markdown";
+  dependencies = [];
+  authoredContent;
+  constructor(authoredContent) {
+    this.authoredContent = authoredContent;
+  }
+  async resolve(_config, _existingNodes) {
+    const nodes = [];
+    const edges = [];
+    for (const [path, raw] of Object.entries(this.authoredContent)) {
+      if (!isRichAuthoredMarkdown(raw)) continue;
+      try {
+        const fragment = ingestRichMarkdown({
+          content: raw,
+          path,
+          cluster: "docs",
+          providerId: PROVIDER_ID
+        });
+        const idRemap = /* @__PURE__ */ new Map();
+        const adapted = [];
+        for (const ingested of fragment.nodes) {
+          const node = adaptIngestedNode(ingested);
+          idRemap.set(ingested.id, node.id);
+          adapted.push(node);
+        }
+        for (const node of adapted) {
+          if (node.connections.length > 0) {
+            node.connections = node.connections.map((conn) => ({
+              ...conn,
+              to: idRemap.get(conn.to) ?? conn.to
+            }));
+          }
+          nodes.push(node);
+        }
+        for (const edge of fragment.edges) {
+          const e = edge;
+          edges.push({
+            ...e,
+            from: idRemap.get(e.from) ?? e.from,
+            to: idRemap.get(e.to) ?? e.to
+          });
+        }
+      } catch {
+        console.warn(`[AuthoredRichMarkdownProvider] Failed to ingest ${path}, skipping`);
+      }
+    }
+    return { nodes, edges };
+  }
+};
+var SCHEMA_PATHS = {
+  teamops: "teamops.yaml",
+  conventions: "schema/conventions.yaml",
+  edges: "schema/edges.yaml",
+  lifecycle: "schema/lifecycle.yaml",
+  context: "index/context.jsonld",
+  /**
+   * Optional cross-repo vocabulary / synonym overlay (#153): a JSON-LD
+   * `@context` mapping per-repo alias terms → a canonical kind. Absent in most
+   * repos, in which case the synonym layer is a safe no-op.
+   */
+  vocabulary: "index/vocabulary.jsonld"
+};
+function hasContentModelSource(source) {
+  if (!source) return false;
+  const f = source.files;
+  return typeof f[SCHEMA_PATHS.teamops] === "string" && typeof f[SCHEMA_PATHS.context] === "string";
+}
+function parseYaml(raw) {
+  if (raw == null) return void 0;
+  try {
+    return yaml.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function parseTeamOps(raw, diags) {
+  const doc = parseYaml(raw) ?? {};
+  const identity = doc.identity ?? doc;
+  const orgsRaw = doc.orgs ?? identity.orgs ?? [];
+  const orgs = orgsRaw.map((o) => ({
+    id: String(o.id ?? ""),
+    name: o.name != null ? String(o.name) : void 0,
+    default: o.default === true
+  }));
+  const authority = String(identity.authority ?? "");
+  let defaultOrg = String(identity.defaultOrg ?? identity.org ?? orgs.find((o) => o.default)?.id ?? "");
+  if (!authority) diags.push({ level: "error", code: "missing-authority", message: "teamops.yaml has no identity.authority" });
+  if (!defaultOrg && orgs.length > 0) defaultOrg = orgs[0].id;
+  return { authority, defaultOrg, orgs };
+}
+function parseConventions(raw, diags) {
+  const doc = parseYaml(raw) ?? {};
+  const kindsRaw = doc.kinds ?? {};
+  const kinds = {};
+  for (const [kind, c] of Object.entries(kindsRaw)) {
+    if (!c || typeof c !== "object") continue;
+    kinds[kind] = {
+      kind,
+      path: String(c.path ?? kind),
+      orgScoped: c.orgScoped === true,
+      aliasField: c.aliasField != null ? String(c.aliasField) : void 0,
+      passthrough: Array.isArray(c.passthrough) ? c.passthrough.map(String) : void 0,
+      companionExt: c.companionExt != null ? String(c.companionExt) : void 0
+    };
+  }
+  if (Object.keys(kinds).length === 0) {
+    diags.push({ level: "warn", code: "no-kinds", message: "conventions.yaml declares no kinds" });
+  }
+  return {
+    typeField: String(doc.typeField ?? "@type"),
+    idField: String(doc.idField ?? "id"),
+    kinds
+  };
+}
+function parseEdges(raw) {
+  const doc = parseYaml(raw) ?? {};
+  const edges = Array.isArray(doc.edges) ? doc.edges : [];
+  const derived = Array.isArray(doc.derived) ? doc.derived : [];
+  const deprecated = Array.isArray(doc.deprecated) ? doc.deprecated : [];
+  for (const d of deprecated) d.relation = "deprecated";
+  return { edges, derived, deprecated };
+}
+function parseLifecycle(raw) {
+  const doc = parseYaml(raw) ?? {};
+  const bandsRaw = doc.bands ?? {};
+  const bands = {};
+  for (const [band, kinds] of Object.entries(bandsRaw)) {
+    bands[band] = Array.isArray(kinds) ? kinds.map(String) : [];
+  }
+  return { bands };
+}
+function normalizeBase(base) {
+  return base.endsWith("/") ? base : `${base}/`;
+}
+function parseContext(raw, diags) {
+  let doc = {};
+  if (raw != null) {
+    try {
+      doc = JSON.parse(raw);
+    } catch {
+      diags.push({ level: "error", code: "bad-context", message: "index/context.jsonld is not valid JSON" });
+    }
+  }
+  const ctx = doc["@context"] ?? doc;
+  const prefixes = {};
+  let base;
+  for (const [key2, value] of Object.entries(ctx)) {
+    if (key2 === "@base") {
+      base = normalizeBase(String(value));
+      continue;
+    }
+    if (key2.startsWith("@")) continue;
+    const iri = typeof value === "string" ? value : value && typeof value === "object" ? String(value["@id"] ?? "") : "";
+    if (iri) prefixes[key2] = normalizeBase(iri);
+  }
+  if (Object.keys(prefixes).length === 0) {
+    diags.push({ level: "error", code: "no-prefixes", message: "context.jsonld declares no CURIE prefixes" });
+  }
+  return { base, prefixes };
+}
+function aliasesFromContext(doc) {
+  const ctx = doc["@context"] ?? doc;
+  const aliases = {};
+  if (!ctx || typeof ctx !== "object" || Array.isArray(ctx)) return aliases;
+  for (const [term, value] of Object.entries(ctx)) {
+    if (term.startsWith("@")) continue;
+    const canonical = typeof value === "string" ? value : value && typeof value === "object" ? String(value["@id"] ?? "") : "";
+    const a = term.trim();
+    const c = canonical.trim();
+    if (!a || !c || a === c) continue;
+    aliases[a] = c;
+  }
+  return aliases;
+}
+function parseVocabularyDoc(raw, diags, sourceLabel = SCHEMA_PATHS.vocabulary) {
+  if (raw == null) return {};
+  let doc;
+  try {
+    doc = JSON.parse(raw);
+  } catch {
+    diags.push({ level: "error", code: "bad-vocabulary", message: `${sourceLabel} is not valid JSON` });
+    return {};
+  }
+  return aliasesFromContext(doc);
+}
+function overlayAliases(overlay, diags) {
+  if (overlay == null) return {};
+  if (typeof overlay === "string") return parseVocabularyDoc(overlay, diags, "vocabulary overlay");
+  return { ...overlay.aliases };
+}
+function canonicalKind(schema, term) {
+  return schema.vocabulary.aliases[term] ?? term;
+}
+function readContentModelSchema(source, overlay) {
+  const diagnostics = [];
+  const f = source.files;
+  const aliases = {
+    ...parseVocabularyDoc(f[SCHEMA_PATHS.vocabulary], diagnostics),
+    ...overlayAliases(overlay, diagnostics)
+  };
+  const schema = {
+    teamops: parseTeamOps(f[SCHEMA_PATHS.teamops], diagnostics),
+    conventions: parseConventions(f[SCHEMA_PATHS.conventions], diagnostics),
+    edges: parseEdges(f[SCHEMA_PATHS.edges]),
+    lifecycle: parseLifecycle(f[SCHEMA_PATHS.lifecycle]),
+    context: parseContext(f[SCHEMA_PATHS.context], diagnostics),
+    vocabulary: { aliases }
+  };
+  return { schema, diagnostics };
+}
+function isOrgScoped(schema, kind) {
+  return schema.conventions.kinds[kind]?.orgScoped === true;
+}
+function urnLocalId(urn) {
+  return stripScheme(urn);
+}
+function buildUrn(schema, kind, id, org, diagnostics) {
+  const base = schema.context.prefixes[kind];
+  if (!base) {
+    diagnostics?.push({ level: "error", code: "unknown-prefix", message: `No URN base in context for kind "${kind}"`, ref: `${kind}:${id}` });
+    return null;
+  }
+  if (isOrgScoped(schema, kind)) {
+    const resolvedOrg = org ?? schema.teamops.defaultOrg;
+    return `${base}${resolvedOrg}/${id}`;
+  }
+  return `${base}${id}`;
+}
+function resolveCurie(schema, curie, opts = {}) {
+  const value = curie.trim();
+  const idx = value.indexOf(":");
+  if (idx < 0) {
+    opts.diagnostics?.push({ level: "warn", code: "not-a-curie", message: `"${curie}" is not a CURIE`, ref: curie });
+    return null;
+  }
+  const local = value.slice(idx + 1);
+  if (local.startsWith("//")) return value;
+  const prefix = value.slice(0, idx);
+  if (!schema.context.prefixes[prefix]) {
+    opts.diagnostics?.push({ level: "warn", code: "unknown-prefix", message: `Unknown CURIE prefix "${prefix}"`, ref: curie });
+    return null;
+  }
+  return buildUrn(schema, prefix, local, opts.org, opts.diagnostics);
+}
+function lifecycleBand(schema, kind) {
+  for (const [band, kinds] of Object.entries(schema.lifecycle.bands)) {
+    if (kinds.includes(kind)) return band;
+  }
+  return void 0;
+}
+function getConvention(schema, kind) {
+  return schema.conventions.kinds[kind];
+}
+var CONTENT_MODEL_PROVIDER = "content-model";
+var NUL = "\0";
+var key = (kind, value) => `${kind}${NUL}${value}`;
+function humanize(s) {
+  return s.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function refOf(v) {
+  if (v == null) return null;
+  if (typeof v === "object") {
+    const id = v.id;
+    return typeof id === "string" && id.trim() ? id.trim() : null;
+  }
+  const s = String(v).trim();
+  return s || null;
+}
+function isSchemaPath(path) {
+  if (path === SCHEMA_PATHS.teamops) return true;
+  const top = path.split("/")[0];
+  return top === "schema" || top === "index";
+}
+var YAML_RE = /\.ya?ml$/i;
+function joinPath(root, path) {
+  const trimmedRoot = root.replace(/\/+$/, "");
+  return trimmedRoot ? `${trimmedRoot}/${path}` : path;
+}
+function sourceFormat(path) {
+  return /\.json$/i.test(path) ? "json" : "yaml";
+}
+function parseYaml2(raw) {
+  try {
+    const doc = yaml.parse(raw);
+    return doc && typeof doc === "object" && !Array.isArray(doc) ? doc : null;
+  } catch {
+    return null;
+  }
+}
+function detectOrg(schema, kind, path, pathRoot) {
+  if (!schema.conventions.kinds[kind]?.orgScoped) return void 0;
+  const prefix = `${pathRoot}/`;
+  const rel = path.startsWith(prefix) ? path.slice(prefix.length) : path;
+  const segments = rel.split("/");
+  return segments.length > 1 ? segments[0] : schema.teamops.defaultOrg;
+}
+function companionBody(files, entityPath, ext) {
+  if (!ext) return void 0;
+  const companion = entityPath.replace(YAML_RE, ext);
+  return companion !== entityPath ? files[companion] : void 0;
+}
+function walkEntities(schema, source, diagnostics) {
+  const { typeField, idField } = schema.conventions;
+  const entries = [];
+  const byKindId = /* @__PURE__ */ new Map();
+  const byKindAlias = /* @__PURE__ */ new Map();
+  for (const [path, raw] of Object.entries(source.files)) {
+    if (isSchemaPath(path) || !YAML_RE.test(path)) continue;
+    const record = parseYaml2(raw);
+    if (!record) {
+      diagnostics.push({ level: "warn", code: "unparsable-entity", message: `Could not parse entity file`, ref: path });
+      continue;
+    }
+    const declaredType = record[typeField] != null ? String(record[typeField]) : "";
+    if (!declaredType) {
+      diagnostics.push({ level: "warn", code: "missing-type", message: `Entity has no ${typeField}`, ref: path });
+      continue;
+    }
+    const kind = canonicalKind(schema, declaredType);
+    const nativeType = kind !== declaredType ? declaredType : void 0;
+    const convention = getConvention(schema, kind);
+    if (!convention) {
+      diagnostics.push({ level: "warn", code: "unknown-kind", message: `No convention for kind "${kind}"`, ref: path });
+      continue;
+    }
+    const id = record[idField] != null ? String(record[idField]) : "";
+    if (!id) {
+      diagnostics.push({ level: "warn", code: "missing-id", message: `Entity has no ${idField}`, ref: path });
+      continue;
+    }
+    const org = detectOrg(schema, kind, path, convention.path);
+    const urn = buildUrn(schema, kind, id, org, diagnostics);
+    if (!urn) continue;
+    const entry = {
+      kind,
+      id,
+      org,
+      urn,
+      record,
+      nativeType,
+      body: companionBody(source.files, path, convention.companionExt),
+      path,
+      raw
+    };
+    entries.push(entry);
+    byKindId.set(key(kind, id), entry);
+    if (convention.aliasField) {
+      const alias = record[convention.aliasField];
+      if (alias != null) byKindAlias.set(key(kind, String(alias)), entry);
+    }
+  }
+  entries.sort((a, b) => a.urn < b.urn ? -1 : a.urn > b.urn ? 1 : 0);
+  return { entries, byKindId, byKindAlias };
+}
+function ldContextOf(schema) {
+  const ctx = { ...schema.context.prefixes };
+  if (schema.context.base) ctx["@base"] = schema.context.base;
+  return Object.keys(ctx).length > 0 ? ctx : "https://schema.org";
+}
+function emitNode(schema, entry, ldContext, root) {
+  const { kind, id, urn, record, body, nativeType } = entry;
+  const title = String(record.name ?? record.title ?? id);
+  const data = { ...record };
+  const band = lifecycleBand(schema, kind);
+  const ldData = { ...data };
+  if (band) ldData.lifecycle = band;
+  if (nativeType) ldData.nativeType = nativeType;
+  const content = body ? renderSafeMarkdown(body) : "";
+  const localId = urnLocalId(urn);
+  const node = {
+    id: localId,
+    title,
+    cluster: kind,
+    content,
+    rawContent: body ?? "",
+    display: "entity",
+    connections: [],
+    derived: true,
+    source: { type: "structured", entityType: kind, ref: id },
+    entityType: kind,
+    provider: CONTENT_MODEL_PROVIDER,
+    data,
+    jsonld: buildJsonLd({ id: localId, identity: urn }, kind, ldData, ldContext),
+    // Pointer to the underlying source-of-truth file so the in-app editor can
+    // edit the real entity file and hand the change off to GitHub as a PR
+    // (F5 — #152). The path is repo-relative (root + entry path).
+    sourceFile: { path: joinPath(root, entry.path), raw: entry.raw, format: sourceFormat(entry.path) }
+  };
+  const identity = assignIdentity(node);
+  if (identity !== void 0) node.identity = identity;
+  return node;
+}
+var EdgeResolver = class {
+  edges = [];
+  edgeKeys = /* @__PURE__ */ new Set();
+  connKeys = /* @__PURE__ */ new Set();
+  stubs = /* @__PURE__ */ new Map();
+  schema;
+  index;
+  nodeByUrn;
+  ldContext;
+  diagnostics;
+  constructor(schema, index, nodeByUrn, ldContext, diagnostics) {
+    this.schema = schema;
+    this.index = index;
+    this.nodeByUrn = nodeByUrn;
+    this.ldContext = ldContext;
+    this.diagnostics = diagnostics;
+  }
+  /** Resolve a reference to a target URN, lazily creating a stub when missing. */
+  resolve(targetKind, ref, mode) {
+    const map = mode === "alias" ? this.index.byKindAlias : this.index.byKindId;
+    const hit = map.get(key(targetKind, ref));
+    if (hit) return hit.urn;
+    return this.stub(targetKind, ref);
+  }
+  /** Lookup-only resolution (no stub creation) — used for derived grouping. */
+  lookup(targetKind, ref, mode) {
+    const map = mode === "alias" ? this.index.byKindAlias : this.index.byKindId;
+    return map.get(key(targetKind, ref))?.urn;
+  }
+  stub(targetKind, ref) {
+    const urn = buildUrn(this.schema, targetKind, ref) ?? `kg://unresolved/${targetKind}/${ref}`;
+    if (!this.stubs.has(urn)) {
+      const data = { id: ref, unresolved: true };
+      const localId = urnLocalId(urn);
+      const node = {
+        id: localId,
+        title: ref,
+        cluster: targetKind,
+        content: "",
+        rawContent: "",
+        display: "entity",
+        connections: [],
+        derived: true,
+        source: { type: "structured", entityType: targetKind, ref },
+        entityType: targetKind,
+        provider: CONTENT_MODEL_PROVIDER,
+        data,
+        jsonld: buildJsonLd({ id: localId, identity: urn }, targetKind, data, this.ldContext)
+      };
+      const identity = assignIdentity(node);
+      if (identity !== void 0) node.identity = identity;
+      this.stubs.set(urn, node);
+      this.nodeByUrn.set(urn, node);
+      this.diagnostics.push({
+        level: "warn",
+        code: "unresolved-ref",
+        message: `Unresolved ${targetKind} reference "${ref}"`,
+        ref: urn
+      });
+    }
+    return urn;
+  }
+  addEdge(from, to, relation, description) {
+    if (from === to) return;
+    const fromId = urnLocalId(from);
+    const toId = urnLocalId(to);
+    const k = `${from}${NUL}${to}${NUL}${relation}`;
+    if (!this.edgeKeys.has(k)) {
+      this.edgeKeys.add(k);
+      this.edges.push({ from: fromId, to: toId, type: "related", relation, description, source: "inferred", weight: 1 });
+    }
+    const ck = `${from}${NUL}${to}${NUL}${relation}`;
+    if (!this.connKeys.has(ck)) {
+      this.connKeys.add(ck);
+      const conn = { to: toId, type: "related", description, source: "inferred", relation };
+      this.nodeByUrn.get(from)?.connections.push(conn);
+    }
+  }
+  /** Apply a single FK rule to one source entry. */
+  applyRule(entry, rule, relationOverride) {
+    const raw = entry.record[rule.field];
+    if (raw == null) return;
+    if (rule.fk === "composite") {
+      const parts = String(raw).split(":").map((p) => p.trim());
+      const legs = rule.composite ?? [];
+      parts.forEach((part, i) => {
+        const leg = legs[i];
+        if (!leg) {
+          this.diagnostics.push({
+            level: "warn",
+            code: "composite-arity",
+            message: `Composite FK "${rule.id}" has no leg for part ${i} ("${part}")`,
+            ref: entry.urn
+          });
+          return;
+        }
+        const to = this.resolve(leg.to, part, "id");
+        this.addEdge(entry.urn, to, leg.relation, rule.description ?? humanize(leg.relation));
+      });
+      return;
+    }
+    const relation = relationOverride ?? rule.relation;
+    const mode = rule.fk === "alias" ? "alias" : "id";
+    const values = rule.fk === "array" ? Array.isArray(raw) ? raw : [raw] : [raw];
+    for (const v of values) {
+      if (v == null) continue;
+      const ref = refOf(v);
+      if (ref == null) {
+        this.diagnostics.push({
+          level: "warn",
+          code: "bad-ref-shape",
+          message: `FK "${rule.id}" entry is an object without a string "id" \u2014 expected an id string (or { id: ... })`,
+          ref: entry.urn
+        });
+        continue;
+      }
+      const to = this.resolve(rule.to ?? "", ref, mode);
+      this.addEdge(entry.urn, to, relation, rule.description ?? humanize(relation));
+    }
+  }
+  /** Pass 4: resolve all FK rules (and deprecated rules, tagged `deprecated`). */
+  resolveForeignKeys() {
+    const byKind = /* @__PURE__ */ new Map();
+    for (const e of this.index.entries) {
+      (byKind.get(e.kind) ?? byKind.set(e.kind, []).get(e.kind)).push(e);
+    }
+    const run = (rules, deprecated) => {
+      for (const rule of rules) {
+        for (const entry of byKind.get(rule.from) ?? []) {
+          this.applyRule(entry, rule, deprecated ? "deprecated" : void 0);
+        }
+      }
+    };
+    run(this.schema.edges.edges, false);
+    run(this.schema.edges.deprecated, true);
+  }
+  /** Pass 5: compute derived `shared-target` edges (deduped, undirected). */
+  resolveDerived() {
+    for (const rule of this.schema.edges.derived) {
+      if (rule.type !== "shared-target") continue;
+      const via = this.schema.edges.edges.find((e) => e.id === rule.via);
+      if (!via || via.fk === "composite" || !via.to) {
+        this.diagnostics.push({
+          level: "warn",
+          code: "bad-derived",
+          message: `Derived rule "${rule.id}" references unusable FK "${rule.via}"`
+        });
+        continue;
+      }
+      const mode = via.fk === "alias" ? "alias" : "id";
+      const groups = /* @__PURE__ */ new Map();
+      for (const entry of this.index.entries) {
+        if (entry.kind !== via.from) continue;
+        const raw = entry.record[via.field];
+        if (raw == null) continue;
+        const refs = via.fk === "array" ? Array.isArray(raw) ? raw : [raw] : [raw];
+        for (const r of refs) {
+          const ref = refOf(r);
+          if (ref == null) continue;
+          const targetUrn = this.lookup(via.to, ref, mode);
+          if (!targetUrn) continue;
+          (groups.get(targetUrn) ?? groups.set(targetUrn, []).get(targetUrn)).push(entry.urn);
+        }
+      }
+      for (const members of groups.values()) {
+        const unique = [...new Set(members)].sort();
+        for (let i = 0; i < unique.length; i++) {
+          for (let j = i + 1; j < unique.length; j++) {
+            this.addEdge(unique[i], unique[j], rule.relation, rule.description ?? humanize(rule.relation));
+          }
+        }
+      }
+    }
+  }
+};
+function buildContentModel(source, vocabularyOverlay) {
+  if (!hasContentModelSource(source)) {
+    return { nodes: [], edges: [], diagnostics: [] };
+  }
+  const src = source;
+  const { schema, diagnostics } = readContentModelSchema(src, vocabularyOverlay);
+  const ldContext = ldContextOf(schema);
+  const index = walkEntities(schema, src, diagnostics);
+  const nodeByUrn = /* @__PURE__ */ new Map();
+  for (const entry of index.entries) {
+    nodeByUrn.set(entry.urn, emitNode(schema, entry, ldContext, src.root));
+  }
+  const resolver = new EdgeResolver(schema, index, nodeByUrn, ldContext, diagnostics);
+  resolver.resolveForeignKeys();
+  resolver.resolveDerived();
+  const nodes = [...nodeByUrn.values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  const edges = resolver.edges.slice().sort((a, b) => {
+    const ka = `${a.from}${NUL}${a.to}${NUL}${a.relation}`;
+    const kb = `${b.from}${NUL}${b.to}${NUL}${b.relation}`;
+    return ka < kb ? -1 : ka > kb ? 1 : 0;
+  });
+  return { nodes, edges, diagnostics };
+}
+
+// src/content-model/register.ts
+var CONTENT_MODEL_KINDS = [
+  { id: "person", label: "Person", layer: "work", relations: ["reports-to"], viewer: "person", description: "An individual in the org." },
+  { id: "squad", label: "Squad", layer: "work", relations: ["leads", "staffs", "structural", "deprecated"], viewer: "squad", description: "A squad that staffs people, is led by a DRI, and delivers a workstream." },
+  { id: "workstream", label: "Workstream", layer: "work", relations: ["structural"], viewer: "workstream", description: "A stream of work aligned to a priority." },
+  { id: "mission", label: "Mission", layer: "work", relations: ["structural"], viewer: "mission", description: "A time-boxed mission assigned to a cycle + squad." },
+  { id: "priority", label: "Priority", layer: "work", relations: [], viewer: "priority", description: "A ranked organizational priority." },
+  { id: "cycle", label: "Cycle", layer: "work", relations: [], viewer: "cycle", description: "A planning cycle (time box)." },
+  { id: "org", label: "Org", layer: "work", relations: [], viewer: "org", description: "An organization with a charter." },
+  // Work-graph organizational-layer descriptor kinds (#233)
+  { id: "team", label: "Team", layer: "work", relations: ["leads", "staffs", "owns"], viewer: "team", description: "A team that leads people and owns workstreams." },
+  { id: "system-of-record", label: "System of Record", layer: "work", relations: ["tracked-in"], viewer: "system-of-record", description: "An external system that tracks a workstream (e.g. an ADO board or GitHub repo)." },
+  // Services-monorepo core kinds (#275)
+  { id: "service", label: "Service", layer: "work", relations: ["owned-by", "tracked-in"], viewer: "service", description: "A deployable service owned by a team, with a ServiceTree id and catalog-info path." },
+  { id: "decision", label: "Decision", layer: "work", relations: ["decided-by", "affects"], viewer: "decision", description: "An architecture decision record (ADR) \u2014 deciders, status, context, and the work it affects." }
+];
+function registerContentModelTypes() {
+  for (const k of CONTENT_MODEL_KINDS) {
+    registerType({
+      id: k.id,
+      label: k.label,
+      layer: k.layer,
+      cluster: k.id,
+      relations: k.relations,
+      viewer: k.viewer,
+      description: k.description
+    });
+  }
+}
+
+// src/providers/content-model-provider.ts
+var ContentModelProvider = class {
+  id = CONTENT_MODEL_PROVIDER;
+  name = "Content Model";
+  dependencies = [];
+  source;
+  /**
+   * Optional cross-repo synonym overlay (#153) supplied independently of the
+   * source's own files — the shared vocabulary layer. Null/absent leaves the
+   * synonym layer a safe no-op.
+   */
+  vocabularyOverlay;
+  constructor(source, vocabularyOverlay) {
+    this.source = source ?? null;
+    this.vocabularyOverlay = vocabularyOverlay ?? null;
+  }
+  async resolve(_config, _existingNodes) {
+    if (!hasContentModelSource(this.source)) {
+      return { nodes: [], edges: [] };
+    }
+    registerContentModelTypes();
+    const { nodes } = buildContentModel(this.source, this.vocabularyOverlay);
+    const anchored = nodes.map((n) => ({
+      ...n,
+      cluster: "teamops",
+      connections: [
+        ...n.connections,
+        {
+          to: "repo-meta",
+          type: "references",
+          relation: "tracked-in",
+          description: "Tracked in this repository",
+          source: "inferred"
+        }
+      ]
+    }));
+    return { nodes: anchored, edges: [] };
+  }
+};
+
+// src/providers/files-provider.ts
+var FilesProvider = class {
+  id = "files";
+  name = "File System";
+  dependencies = [];
+  treeItems;
+  repoName;
+  excludePaths;
+  constructor(treeItems, repoName, excludePaths) {
+    this.treeItems = treeItems;
+    this.repoName = repoName;
+    this.excludePaths = excludePaths;
+  }
+  async resolve(_config, _existingNodes) {
+    const nodes = treeToNodes(this.treeItems, this.repoName, this.excludePaths);
+    for (const node of nodes) {
+      node.provider = "files";
+      if (!node.identity) {
+        const identity = assignIdentity(node);
+        if (identity !== void 0) node.identity = identity;
+      }
+    }
+    return { nodes, edges: [] };
+  }
+};
+var DEFAULT_MIN_ACTIVE_ITEMS = 1;
+var PersonProvider = class {
+  id = "person";
+  name = "People";
+  /**
+   * Run after work so we can match existing nodes; run after content-model
+   * so we can link to descriptor people.
+   */
+  dependencies = ["work", "content-model"];
+  issues;
+  pullRequests;
+  constructor(issues, pullRequests) {
+    this.issues = issues;
+    this.pullRequests = pullRequests;
+  }
+  async resolve(config, existingNodes) {
+    const minActive = config.people?.minActiveItems ?? DEFAULT_MIN_ACTIVE_ITEMS;
+    const byLogin = /* @__PURE__ */ new Map();
+    function ensureLogin(login) {
+      let d = byLogin.get(login);
+      if (!d) {
+        d = { login, assignedIssues: [], authoredIssues: [], assignedPRs: [], authoredPRs: [] };
+        byLogin.set(login, d);
+      }
+      return d;
+    }
+    for (const issue of this.issues) {
+      if (issue.state !== "open") continue;
+      for (const a of issue.assignees ?? []) {
+        ensureLogin(a.login).assignedIssues.push(issue);
+      }
+      if (issue.user?.login) {
+        ensureLogin(issue.user.login).authoredIssues.push(issue);
+      }
+    }
+    for (const pr of this.pullRequests) {
+      if (pr.state !== "open") continue;
+      for (const a of pr.assignees ?? []) {
+        ensureLogin(a.login).assignedPRs.push(pr);
+      }
+      if (pr.user?.login) {
+        ensureLogin(pr.user.login).authoredPRs.push(pr);
+      }
+    }
+    const qualifying = [...byLogin.values()].filter((d) => {
+      const activeCount = d.assignedIssues.length + d.authoredIssues.length + d.assignedPRs.length + d.authoredPRs.length;
+      return activeCount >= minActive;
+    });
+    if (qualifying.length === 0) return { nodes: [], edges: [] };
+    const descriptorByAlias = /* @__PURE__ */ new Map();
+    for (const n of existingNodes) {
+      if (n.entityType === "person" || n.source.type === "structured" && n.source.entityType === "person") {
+        const alias = n.data?.alias;
+        if (alias) descriptorByAlias.set(alias.toLowerCase(), n);
+        const descId = n.data?.id;
+        if (descId) descriptorByAlias.set(descId.toLowerCase(), n);
+      }
+    }
+    const nodes = [];
+    const edges = [];
+    for (const d of qualifying) {
+      const loginLower = d.login.toLowerCase();
+      const descriptor = descriptorByAlias.get(loginLower);
+      const connections = [];
+      const seen = /* @__PURE__ */ new Set();
+      const addConn = (to, relation) => {
+        if (!seen.has(to)) {
+          connections.push({
+            to,
+            relation,
+            description: relation === "assigned-to" ? "Assigned to" : "Authored",
+            type: "related",
+            source: "inferred"
+          });
+          seen.add(to);
+        }
+      };
+      for (const issue of d.assignedIssues) addConn(`issue-${issue.number}`, "assigned-to");
+      for (const issue of d.authoredIssues) addConn(`issue-${issue.number}`, "authored");
+      for (const pr of d.assignedPRs) addConn(`pr-${pr.number}`, "assigned-to");
+      for (const pr of d.authoredPRs) addConn(`pr-${pr.number}`, "authored");
+      if (descriptor) {
+        const witness = {
+          kind: "github",
+          href: urnIdentity("person", d.login),
+          resourceKind: "person"
+        };
+        const refs = descriptor.linkedRefs ?? [];
+        if (!refs.some((r) => r.href === witness.href)) {
+          descriptor.linkedRefs = [...refs, witness];
+        }
+        const uniqueIssuesD = [
+          ...d.assignedIssues,
+          ...d.authoredIssues.filter((i) => !d.assignedIssues.some((a) => a.number === i.number))
+        ];
+        const uniquePRsD = [
+          ...d.assignedPRs,
+          ...d.authoredPRs.filter((pr) => !d.assignedPRs.some((a) => a.number === pr.number))
+        ];
+        descriptor.data = {
+          ...descriptor.data ?? {},
+          login: d.login,
+          activeIssues: uniqueIssuesD.map((i) => ({ number: i.number, title: i.title })),
+          activePRs: uniquePRsD.map((pr) => ({ number: pr.number, title: pr.title })),
+          activeIssueCount: uniqueIssuesD.length,
+          activePRCount: uniquePRsD.length
+        };
+        for (const conn of connections) {
+          const alreadyPresent = descriptor.connections.some((c) => c.to === conn.to);
+          if (!alreadyPresent) descriptor.connections.push(conn);
+        }
+        for (const conn of connections) {
+          edges.push({
+            from: descriptor.id,
+            to: conn.to,
+            type: "related",
+            ...conn.relation ? { relation: conn.relation } : {},
+            description: conn.description ?? "",
+            source: "inferred",
+            weight: 1.5
+          });
+        }
+        continue;
+      }
+      const uniqueIssues = [
+        ...d.assignedIssues,
+        ...d.authoredIssues.filter((i) => !d.assignedIssues.some((a) => a.number === i.number))
+      ];
+      const uniquePRs = [
+        ...d.assignedPRs,
+        ...d.authoredPRs.filter((p) => !d.assignedPRs.some((a) => a.number === p.number))
+      ];
+      const issueLines = uniqueIssues.map(
+        (i) => `- [#${i.number}: ${i.title}](issue-${i.number}) *(issue)*`
+      );
+      const prLines = uniquePRs.map(
+        (p) => `- [#${p.number}: ${p.title}](pr-${p.number}) *(PR)*`
+      );
+      const allLines = [...issueLines, ...prLines];
+      const rawContent = [
+        `## @${d.login}`,
+        "",
+        `**GitHub login:** \`${d.login}\``,
+        "",
+        `### Active work (${allLines.length} item${allLines.length !== 1 ? "s" : ""})`,
+        "",
+        ...allLines
+      ].join("\n");
+      const content = renderSafeMarkdown(rawContent);
+      const nodeId = `person-${d.login}`;
+      const personNode = {
+        id: nodeId,
+        title: `@${d.login}`,
+        cluster: "work",
+        content,
+        rawContent,
+        emoji: "Person",
+        display: "entity",
+        connections,
+        source: { type: "person", login: d.login, linked: false },
+        provider: "person",
+        entityType: "person",
+        derived: true,
+        // Core v0.3.0 identity/link substrate (#445 / AF-013): alongside the
+        // legacy source witness, point at the person's canonical, host-neutral
+        // address (`buildPersonAddress(login)` — the alias-based `kg://` form
+        // cli/directory providers mint). kbexplorer-cli's edge-mint resolves
+        // linkedRef hrefs against node identities, so this is what makes
+        // template person nodes visible to its identity-linking at all.
+        linkedRefs: [
+          {
+            kind: "github",
+            href: buildPersonAddress(d.login),
+            resourceKind: "person"
+          }
+        ],
+        data: {
+          login: d.login,
+          activeIssues: uniqueIssues.map((i) => ({ number: i.number, title: i.title })),
+          activePRs: uniquePRs.map((p) => ({ number: p.number, title: p.title })),
+          activeIssueCount: uniqueIssues.length,
+          activePRCount: uniquePRs.length
+        }
+      };
+      const identity = assignIdentity(personNode);
+      if (identity !== void 0) personNode.identity = identity;
+      nodes.push(personNode);
+      for (const conn of connections) {
+        edges.push({
+          from: nodeId,
+          to: conn.to,
+          type: "related",
+          ...conn.relation ? { relation: conn.relation } : {},
+          description: conn.description ?? "",
+          source: "inferred",
+          weight: 1.5
+        });
+      }
+    }
+    return { nodes, edges };
+  }
+};
+var REPO_NODE_ID = "repo-meta";
+var STRUCTURAL_CLUSTER = "infra";
+function registerStructuralTypes() {
+  registerType({ id: "workflow", label: "Workflow", layer: "work", cluster: STRUCTURAL_CLUSTER, relations: ["structural"], viewer: "workflow", description: "A GitHub Actions workflow." });
+  registerType({ id: "github-action", label: "Action", layer: "work", cluster: STRUCTURAL_CLUSTER, relations: ["structural"], viewer: "github-action", description: "A composite or JS GitHub Action." });
+  registerType({ id: "skill", label: "Skill", layer: "work", cluster: STRUCTURAL_CLUSTER, relations: ["structural"], viewer: "skill", description: "A Copilot / agent skill (SKILL.md): when-to-use triggers + guidance." });
+  registerType({ id: "issue-template", label: "Issue Template", layer: "work", cluster: STRUCTURAL_CLUSTER, relations: ["structural"], description: "A GitHub issue template / form." });
+  registerType({ id: "pr-template", label: "PR Template", layer: "work", cluster: STRUCTURAL_CLUSTER, relations: ["structural"], description: "A pull-request template." });
+  registerType({ id: "codeowners", label: "CODEOWNERS", layer: "work", cluster: STRUCTURAL_CLUSTER, relations: ["structural"], description: "Code ownership rules." });
+  registerType({ id: "dependabot-config", label: "Dependabot", layer: "work", cluster: STRUCTURAL_CLUSTER, relations: ["structural"], description: "Dependabot update configuration." });
+  registerType({ id: "funding-config", label: "Funding", layer: "work", cluster: STRUCTURAL_CLUSTER, relations: ["structural"], description: "Repository funding links." });
+  registerType({ id: "github-config", label: "Repo Config", layer: "work", cluster: STRUCTURAL_CLUSTER, relations: ["structural"], description: "Generic repository configuration file." });
+  registerType({ id: "structured-config", label: "Config", layer: "work", cluster: STRUCTURAL_CLUSTER, relations: ["structural"], description: "Heuristically-typed structured config." });
+}
+function fileName2(path) {
+  return path.split("/").pop() ?? path;
+}
+function isWorkflow(path) {
+  return /^\.github\/workflows\/[^/]+\.ya?ml$/i.test(path);
+}
+function isAction(path) {
+  return /(^|\/)action\.ya?ml$/i.test(path);
+}
+function isSkill(path) {
+  return /^\.github\/skills\/.+\/SKILL\.md$/i.test(path) || /(^|\/)[^/]+\.skill\.md$/i.test(path);
+}
+function isIssueTemplate(path) {
+  return /^\.github\/ISSUE_TEMPLATE\/.+/i.test(path) && !/\/config\.ya?ml$/i.test(path);
+}
+function isIssueTemplateConfig(path) {
+  return /^\.github\/ISSUE_TEMPLATE\/config\.ya?ml$/i.test(path);
+}
+function isPrTemplate(path) {
+  return /^\.github\/(PULL_REQUEST_TEMPLATE|pull_request_template)\.md$/i.test(path) || /^\.github\/PULL_REQUEST_TEMPLATE\/.+\.md$/i.test(path);
+}
+function isCodeowners(path) {
+  return /(^|\/)CODEOWNERS$/.test(path);
+}
+function isDependabot(path) {
+  return /^\.github\/dependabot\.ya?ml$/i.test(path);
+}
+function isFunding(path) {
+  return /^\.github\/FUNDING\.ya?ml$/i.test(path);
+}
+function structuralConnection(to, description) {
+  return { to, type: "contains", relation: "structural", description, source: "inferred", weight: 5 };
+}
+function buildStructuralNode(args) {
+  return {
+    id: args.id,
+    title: args.title,
+    cluster: STRUCTURAL_CLUSTER,
+    content: args.content ?? "",
+    rawContent: args.rawContent ?? "",
+    emoji: args.emoji,
+    ...args.display !== void 0 ? { display: args.display } : {},
+    connections: [structuralConnection(args.repoNodeId, `${args.title} configures the repository`)],
+    identity: args.identity,
+    derived: true,
+    source: args.source,
+    provider: "structural",
+    entityType: args.entityType,
+    ...args.data !== void 0 ? { data: args.data } : {},
+    jsonld: buildJsonLd({ id: args.id, identity: args.identity }, args.ldType, args.ldProps ?? {})
+  };
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) return { data: {}, body: raw };
+  try {
+    const data = yaml.parse(match[1] ?? "");
+    return { data: data ?? {}, body: match[2] ?? "" };
+  } catch {
+    return { data: {}, body: raw };
+  }
+}
+function safeYaml(content) {
+  try {
+    const parsed = yaml.parse(content);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function parseCodeowners(content) {
+  const rules = [];
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const parts = trimmed.split(/\s+/);
+    const pattern = parts.shift();
+    if (!pattern) continue;
+    rules.push({ pattern, owners: parts });
+  }
+  return rules;
+}
+function buildWorkflowNode(path, content, repoNodeId) {
+  const data = safeYaml(content);
+  const name = typeof data.name === "string" && data.name || fileName2(path);
+  return buildStructuralNode({
+    id: `gh-workflow-${slugify(fileName2(path))}`,
+    title: name,
+    entityType: "workflow",
+    ldType: "Workflow",
+    source: { type: "workflow", path },
+    identity: urnIdentity("structural", path),
+    emoji: "Flow",
+    data,
+    ldProps: { name },
+    display: "entity",
+    repoNodeId
+  });
+}
+function buildActionNode(path, content, repoNodeId) {
+  const data = safeYaml(content);
+  const name = typeof data.name === "string" && data.name || fileName2(path);
+  return buildStructuralNode({
+    id: `gh-action-${slugify(path)}`,
+    title: name,
+    entityType: "github-action",
+    ldType: "SoftwareApplication",
+    source: { type: "structured", entityType: "github-action", ref: path },
+    identity: urnIdentity("structural", path),
+    emoji: "PuzzlePiece",
+    data,
+    ldProps: { name },
+    display: "entity",
+    repoNodeId
+  });
+}
+function buildSkillNode(path, content, repoNodeId) {
+  const { data, body } = parseFrontmatter(content);
+  const defaultName = /\/SKILL\.md$/i.test(path) ? path.split("/").slice(-2, -1)[0] ?? fileName2(path) : fileName2(path).replace(/\.skill\.md$/i, "");
+  const name = typeof data.name === "string" && data.name || defaultName;
+  const html = renderSafeMarkdown(body);
+  const ldProps = { name };
+  if (typeof data.version === "string") ldProps.version = data.version;
+  return buildStructuralNode({
+    id: `gh-skill-${slugify(name)}`,
+    title: name,
+    entityType: "skill",
+    ldType: "HowTo",
+    source: { type: "structured", entityType: "skill", ref: path },
+    identity: urnIdentity("structural", path),
+    emoji: "BookOpenLightbulb",
+    data,
+    ldProps,
+    content: html,
+    rawContent: body,
+    display: "entity",
+    repoNodeId
+  });
+}
+function buildMarkdownTemplateNode(path, content, entityType, ldType, emoji, repoNodeId) {
+  const { data, body } = parseFrontmatter(content);
+  const title = typeof data.name === "string" && data.name || typeof data.about === "string" && data.about || fileName2(path);
+  const hasData = Object.keys(data).length > 0;
+  const html = renderSafeMarkdown(body);
+  return buildStructuralNode({
+    id: `gh-${entityType}-${slugify(fileName2(path))}`,
+    title,
+    entityType,
+    ldType,
+    source: { type: "structured", entityType, ref: path },
+    identity: urnIdentity("structural", path),
+    emoji,
+    data: hasData ? data : void 0,
+    ldProps: typeof data.name === "string" ? { name: data.name } : {},
+    content: html,
+    rawContent: body,
+    display: hasData ? "entity" : void 0,
+    repoNodeId
+  });
+}
+function buildYamlFormNode(path, content, repoNodeId) {
+  const data = safeYaml(content);
+  const name = typeof data.name === "string" && data.name || fileName2(path);
+  return buildStructuralNode({
+    id: `gh-issue-template-${slugify(fileName2(path))}`,
+    title: name,
+    entityType: "issue-template",
+    ldType: "CreativeWork",
+    source: { type: "structured", entityType: "issue-template", ref: path },
+    identity: urnIdentity("structural", path),
+    emoji: "TextBulletListSquare",
+    data,
+    ldProps: { name },
+    display: "entity",
+    repoNodeId
+  });
+}
+function buildCodeownersNode(path, content, repoNodeId) {
+  const rules = parseCodeowners(content);
+  return buildStructuralNode({
+    id: `gh-codeowners-${slugify(path)}`,
+    title: "CODEOWNERS",
+    entityType: "codeowners",
+    ldType: "StructuredConfig",
+    source: { type: "structured", entityType: "codeowners", ref: path },
+    identity: urnIdentity("structural", path),
+    emoji: "People",
+    data: { rules },
+    ldProps: { ruleCount: rules.length },
+    display: "entity",
+    repoNodeId
+  });
+}
+function buildDependabotNode(path, content, repoNodeId) {
+  const data = safeYaml(content);
+  return buildStructuralNode({
+    id: `gh-dependabot-${slugify(fileName2(path))}`,
+    title: "Dependabot",
+    entityType: "dependabot-config",
+    ldType: "DependabotConfig",
+    source: { type: "structured", entityType: "dependabot-config", ref: path },
+    identity: urnIdentity("structural", path),
+    emoji: "ArrowSync",
+    data,
+    ldProps: typeof data.version !== "undefined" ? { schemaVersion: data.version } : {},
+    display: "entity",
+    repoNodeId
+  });
+}
+function buildFundingNode(path, content, repoNodeId) {
+  const data = safeYaml(content);
+  return buildStructuralNode({
+    id: `gh-funding-${slugify(fileName2(path))}`,
+    title: "Funding",
+    entityType: "funding-config",
+    ldType: "StructuredConfig",
+    source: { type: "structured", entityType: "funding-config", ref: path },
+    identity: urnIdentity("structural", path),
+    emoji: "Heart",
+    data,
+    display: "entity",
+    repoNodeId
+  });
+}
+function isMarkdown(path) {
+  return /\.m*md$/i.test(path) || /\.markdown$/i.test(path);
+}
+function buildGenericConfigNode(path, content, map, repoNodeId) {
+  const mapped = applyStructuredNodeMap({ path, content }, map, {
+    id: `gh-config-${slugify(path)}`,
+    cluster: STRUCTURAL_CLUSTER
+  });
+  if (mapped) {
+    mapped.provider = "structural";
+    mapped.derived = true;
+    if (!mapped.connections.some((c) => c.to === repoNodeId)) {
+      mapped.connections.push(structuralConnection(repoNodeId, `${mapped.title} configures the repository`));
+    }
+    return mapped;
+  }
+  if (isMarkdown(path)) {
+    const { data, body } = parseFrontmatter(content);
+    const html = renderSafeMarkdown(body);
+    const hasData = Object.keys(data).length > 0;
+    return buildStructuralNode({
+      id: `gh-doc-${slugify(fileName2(path))}`,
+      title: typeof data.name === "string" && data.name || fileName2(path),
+      entityType: "github-config",
+      ldType: "CreativeWork",
+      source: { type: "structured", entityType: "github-config", ref: path },
+      identity: urnIdentity("structural", path),
+      emoji: "Document",
+      data: hasData ? data : void 0,
+      content: html,
+      rawContent: body,
+      display: hasData ? "entity" : void 0,
+      repoNodeId
+    });
+  }
+  return null;
+}
+function buildStructuralFileNode(path, content, map, repoNodeId = REPO_NODE_ID) {
+  if (typeof content !== "string") return null;
+  if (isWorkflow(path)) return buildWorkflowNode(path, content, repoNodeId);
+  if (isAction(path)) return buildActionNode(path, content, repoNodeId);
+  if (isSkill(path)) return buildSkillNode(path, content, repoNodeId);
+  if (isDependabot(path)) return buildDependabotNode(path, content, repoNodeId);
+  if (isFunding(path)) return buildFundingNode(path, content, repoNodeId);
+  if (isCodeowners(path)) return buildCodeownersNode(path, content, repoNodeId);
+  if (isIssueTemplateConfig(path)) return buildYamlFormNode(path, content, repoNodeId);
+  if (isIssueTemplate(path)) {
+    return isMarkdown(path) ? buildMarkdownTemplateNode(path, content, "issue-template", "CreativeWork", "TextBulletListSquare", repoNodeId) : buildYamlFormNode(path, content, repoNodeId);
+  }
+  if (isPrTemplate(path)) {
+    return buildMarkdownTemplateNode(path, content, "pr-template", "CreativeWork", "BranchRequest", repoNodeId);
+  }
+  return buildGenericConfigNode(path, content, map, repoNodeId);
+}
+var StructuralProvider = class {
+  id = "structural";
+  name = "Repo Structure";
+  dependencies = ["work"];
+  structuralFiles;
+  structuredNodeMapRaw;
+  repoNodeId;
+  constructor(structuralFiles = {}, structuredNodeMapRaw = null, repoNodeId = REPO_NODE_ID) {
+    this.structuralFiles = structuralFiles;
+    this.structuredNodeMapRaw = structuredNodeMapRaw;
+    this.repoNodeId = repoNodeId;
+  }
+  async resolve(_config, _existingNodes) {
+    const entries = Object.entries(this.structuralFiles ?? {});
+    if (entries.length === 0) return { nodes: [], edges: [] };
+    registerStructuralTypes();
+    const map = parseStructuredNodeMap(this.structuredNodeMapRaw);
+    const nodes = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const [path, content] of entries.sort(([a], [b]) => a.localeCompare(b))) {
+      const node = buildStructuralFileNode(path, content, map, this.repoNodeId);
+      if (!node) continue;
+      let id = node.id;
+      let n = 2;
+      while (seen.has(id)) id = `${node.id}-${n++}`;
+      node.id = id;
+      seen.add(id);
+      nodes.push(node);
+    }
+    return { nodes, edges: [] };
+  }
+};
+
+// src/providers/work-provider.ts
+var DATE_FORMAT = { month: "short", day: "numeric", year: "numeric", timeZone: "UTC" };
+var SHORT_DATE_FORMAT = { month: "short", day: "numeric", timeZone: "UTC" };
+var WorkProvider = class {
+  id = "work";
+  name = "Work Items";
+  dependencies = [];
+  issues;
+  pullRequests;
+  commits;
+  branches;
+  repoMetadata;
+  releases;
+  constructor(issues, pullRequests, commits, branches = [], repoMetadata = null, releases = []) {
+    this.issues = issues;
+    this.pullRequests = pullRequests;
+    this.commits = commits;
+    this.branches = branches;
+    this.repoMetadata = repoMetadata;
+    this.releases = releases;
+  }
+  async resolve(_config, _existingNodes) {
+    const nodes = [];
+    const knownIssueNumbers = new Set(this.issues.map((i) => i.number));
+    const knownPrNumbers = new Set(this.pullRequests.map((p) => p.number));
+    const repoNodeId = this.repoMetadata ? "repo-meta" : void 0;
+    for (const issue of this.issues) {
+      const node = issueToNode(issue, {
+        knownIssueNumbers,
+        knownPrNumbers,
+        ...repoNodeId !== void 0 ? { repoNodeId } : {}
+      });
+      node.provider = "work";
+      const identity = assignIdentity(node);
+      if (identity !== void 0) node.identity = identity;
+      nodes.push(node);
+    }
+    for (const pr of this.pullRequests) {
+      const body = pr.body ?? "";
+      const remappedBody = body.replace(/https?:\/\/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/g, (_m, num) => `issue-${num}`).replace(/https?:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)/g, (_m, num) => `pr-${num}`);
+      const refs = extractIssueRefs(body);
+      const stateEmoji = pr.state === "open" ? "\u{1F7E2}" : pr.state === "merged" ? "\u{1F7E3}" : "\u{1F534}";
+      const labelBadges = pr.labels?.map((l) => `\`${l.name}\``).join(" ") ?? "";
+      const created = new Date(pr.created_at).toLocaleDateString("en-US", DATE_FORMAT);
+      const updated = new Date(pr.updated_at).toLocaleDateString("en-US", DATE_FORMAT);
+      const metaLines = [
+        `${stateEmoji} **${(pr.state || "closed").toUpperCase()}** \xB7 PR #${pr.number}`,
+        labelBadges ? `Labels: ${labelBadges}` : "",
+        `Created: ${created} \xB7 Updated: ${updated}`,
+        `[View on GitHub \u2197](${pr.html_url})`
+      ].filter(Boolean).join("\n\n");
+      const fullContent = `${metaLines}
+
+---
+
+${remappedBody}`;
+      const html = renderSafeMarkdown(fullContent);
+      const connections = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const n of refs) {
+        if (n === pr.number) continue;
+        if (knownIssueNumbers.has(n)) {
+          const to = `issue-${n}`;
+          if (!seen.has(to)) {
+            connections.push({ to, description: `References #${n}` });
+            seen.add(to);
+          }
+        } else if (knownPrNumbers.has(n)) {
+          const to = `pr-${n}`;
+          if (!seen.has(to)) {
+            connections.push({ to, description: `References #${n}` });
+            seen.add(to);
+          }
+        }
+      }
+      if (pr.head_branch) {
+        connections.push({ to: `branch-${pr.head_branch}`, description: `Branch: ${pr.head_branch}` });
+      }
+      if (repoNodeId) {
+        connections.push({
+          to: repoNodeId,
+          type: "contains",
+          relation: "tracked-in",
+          description: "Tracked in repository",
+          source: "inferred"
+        });
+      }
+      const prNode = {
+        id: `pr-${pr.number}`,
+        title: pr.title,
+        cluster: "work",
+        content: html,
+        rawContent: fullContent,
+        emoji: "BranchFork",
+        connections,
+        source: { type: "pull_request", number: pr.number, state: pr.state },
+        provider: "work"
+      };
+      if (repoNodeId) prNode.parent = repoNodeId;
+      const prIdentity = assignIdentity(prNode);
+      if (prIdentity !== void 0) prNode.identity = prIdentity;
+      nodes.push(prNode);
+    }
+    if (this.commits.length > 0) {
+      const commitList = this.commits.slice(0, 30).map((c) => {
+        const msg = c.commit.message.split("\n")[0];
+        const date = new Date(c.commit.author.date).toLocaleDateString("en-US", SHORT_DATE_FORMAT);
+        const refs = extractIssueRefs(c.commit.message);
+        const refLinks = refs.map((n) => `[#${n}](issue-${n})`).join(" ");
+        return `- \`${c.sha.substring(0, 7)}\` ${msg}${refLinks ? " \u2014 " + refLinks : ""} *(${date})*`;
+      }).join("\n");
+      const commitConnections = [];
+      const seenRefs = /* @__PURE__ */ new Set();
+      for (const c of this.commits) {
+        for (const n of extractIssueRefs(c.commit.message)) {
+          if (knownIssueNumbers.has(n)) {
+            const to = `issue-${n}`;
+            if (!seenRefs.has(to)) {
+              commitConnections.push({ to, description: `Commit references #${n}` });
+              seenRefs.add(to);
+            }
+          } else if (knownPrNumbers.has(n)) {
+            const to = `pr-${n}`;
+            if (!seenRefs.has(to)) {
+              commitConnections.push({ to, description: `Commit references #${n}` });
+              seenRefs.add(to);
+            }
+          }
+        }
+      }
+      if (repoNodeId) {
+        commitConnections.push({
+          to: repoNodeId,
+          type: "contains",
+          relation: "tracked-in",
+          description: "Commits in repository",
+          source: "inferred"
+        });
+      }
+      const commitContent = `## Recent Commits
+
+${this.commits.length} commits \xB7 ${this.commits[0]?.commit.author.name ?? "unknown"}
+
+${commitList}`;
+      const commitHtml = renderSafeMarkdown(commitContent);
+      nodes.push({
+        id: "commits",
+        title: "Recent Commits",
+        cluster: "work",
+        content: commitHtml,
+        rawContent: commitContent,
+        emoji: "History",
+        connections: commitConnections,
+        source: { type: "commit", sha: "summary" },
+        provider: "work",
+        ...repoNodeId ? { parent: repoNodeId } : {}
+      });
+    }
+    if (this.repoMetadata) {
+      const meta = this.repoMetadata;
+      const langList = meta.languages.sort((a, b) => b.size - a.size).slice(0, 10).map((l) => `- **${l.name}** (${Math.round(l.size / 1024)}KB)`).join("\n");
+      const topicBadges = meta.topics.map((t) => `\`${t}\``).join(" ");
+      const repoContent = [
+        `${meta.private ? "\u{1F512} Private" : "\u{1F310} Public"} \xB7 \u2B50 ${meta.stargazers_count} \xB7 \u{1F374} ${meta.forks_count}`,
+        meta.description ? `
+${meta.description}` : "",
+        topicBadges ? `
+
+Topics: ${topicBadges}` : "",
+        `
+
+## Languages
+
+${langList || "No language data"}`,
+        `
+
+Default branch: \`${meta.default_branch}\``,
+        `
+
+[View on GitHub \u2197](${meta.html_url})`
+      ].join("");
+      const repoHtml = renderSafeMarkdown(repoContent);
+      const repoConns = [
+        { to: "readme", description: "README" },
+        { to: `branch-${meta.default_branch}`, description: `Default branch` },
+        // Tie the GitHub-side repo node to the file-tree root so the source
+        // tree and the repository are one navigable cluster (the two nodes
+        // describe the same repo; without this they float independently).
+        { to: "repo-root", description: "Source tree", type: "contains", source: "inferred" }
+      ];
+      nodes.push({
+        id: "repo-meta",
+        title: meta.name,
+        cluster: "infra",
+        content: repoHtml,
+        rawContent: repoContent,
+        emoji: "Organization",
+        display: "repository",
+        ...meta.owner.avatar_url ? { image: meta.owner.avatar_url } : {},
+        connections: repoConns,
+        source: { type: "repository", owner: meta.owner.login, repo: meta.name },
+        provider: "work"
+      });
+    }
+    for (const branch of this.branches) {
+      const protectedBadge = branch.protected ? "\u{1F6E1}\uFE0F Protected" : "";
+      const isDefault = this.repoMetadata?.default_branch === branch.name;
+      const branchContent = [
+        `${isDefault ? "**Default branch**" : "Branch"} \xB7 \`${branch.name}\``,
+        protectedBadge ? ` \xB7 ${protectedBadge}` : ""
+      ].join("");
+      const branchHtml = renderSafeMarkdown(branchContent);
+      const branchConns = [];
+      if (repoNodeId) {
+        branchConns.push({
+          to: repoNodeId,
+          type: "contains",
+          relation: "tracked-in",
+          description: isDefault ? "Default branch of repository" : "Branch in repository",
+          source: "inferred"
+        });
+      }
+      nodes.push({
+        id: `branch-${branch.name}`,
+        title: branch.name,
+        // Branches are a structural property of the repository — keep them in
+        // the same cluster so the legend doesn't split branch-isms (the old
+        // code put default in `infra` and the rest in `pull-request` which was
+        // visually inconsistent).
+        cluster: "infra",
+        content: branchHtml,
+        rawContent: branchContent,
+        emoji: branch.protected ? "ShieldCheckmark" : "Branch",
+        connections: branchConns,
+        source: { type: "branch", name: branch.name, protected: branch.protected },
+        provider: "work",
+        ...repoNodeId ? { parent: repoNodeId } : {}
+      });
+    }
+    for (const release of this.releases) {
+      const tag = release.tag_name;
+      const body = release.body ?? "";
+      const prereleaseBadge = release.prerelease ? "\u{1F536} **PRE-RELEASE**" : "\u{1F7E2} **RELEASE**";
+      const pubDate = release.published_at ? new Date(release.published_at).toLocaleDateString("en-US", DATE_FORMAT) : "";
+      const metaLines = [
+        `${prereleaseBadge} \xB7 \`${tag}\``,
+        pubDate ? `Published: ${pubDate}` : "",
+        `[View on GitHub \u2197](${release.html_url})`
+      ].filter(Boolean).join("\n\n");
+      const fullContent = `${metaLines}
+
+---
+
+${body}`;
+      const html = renderSafeMarkdown(fullContent);
+      const connections = [];
+      if (this.repoMetadata) {
+        connections.push({ to: "repo-meta", description: "Repository", type: "contains" });
+      }
+      const refs = extractIssueRefs(body);
+      const seenRefs = /* @__PURE__ */ new Set();
+      for (const n of refs) {
+        if (knownPrNumbers.has(n)) {
+          const prTo = `pr-${n}`;
+          if (!seenRefs.has(prTo)) {
+            connections.push({ to: prTo, description: `Ships PR #${n}`, type: "ships" });
+            seenRefs.add(prTo);
+          }
+        } else if (knownIssueNumbers.has(n)) {
+          const issueTo = `issue-${n}`;
+          if (!seenRefs.has(issueTo)) {
+            connections.push({ to: issueTo, description: `Closes #${n}`, type: "closes" });
+            seenRefs.add(issueTo);
+          }
+        }
+      }
+      const releaseNode = {
+        id: `release-${tag}`,
+        title: release.name || tag,
+        cluster: "work",
+        content: html,
+        rawContent: fullContent,
+        emoji: release.prerelease ? "Beaker" : "Rocket",
+        connections,
+        source: { type: "release", tag, prerelease: release.prerelease },
+        provider: "work",
+        data: {
+          tag_name: tag,
+          html_url: release.html_url,
+          published_at: release.published_at,
+          prerelease: release.prerelease
+        }
+      };
+      const releaseIdentity = assignIdentity(releaseNode);
+      if (releaseIdentity !== void 0) releaseNode.identity = releaseIdentity;
+      nodes.push(releaseNode);
+    }
+    return { nodes, edges: [] };
+  }
+};
+
+// src/orchestrator.ts
+async function collectProviderNodes(registry, config) {
+  const providers = registry.getExecutionOrder();
+  const allNodes = [];
+  for (const provider of providers) {
+    const result = await provider.resolve(config, allNodes);
+    allNodes.push(...result.nodes);
+  }
+  return allNodes;
+}
+async function orchestrate(registry, config) {
+  const allNodes = await collectProviderNodes(registry, config);
+  const clusters = extractClusters(allNodes, config);
+  return buildGraph(allNodes, clusters);
+}
+async function orchestrateWithTransforms(registry, config, ctx, transforms = DEFAULT_TRANSFORMS) {
+  const allNodes = await collectProviderNodes(registry, config);
+  const transformed = applyTransforms(allNodes, ctx, transforms);
+  const clusters = extractClusters(transformed, config);
+  return buildGraph(transformed, clusters);
+}
+
+// src/loader.ts
+function registerProviders(registry, data) {
+  if (data.tree.length > 0) {
+    registry.register(new FilesProvider(data.tree, data.repo));
+  }
+  if (Object.keys(data.authoredContent).length > 0 || data.nodemapRaw) {
+    registry.register(new AuthoredProvider(
+      data.authoredContent,
+      data.nodemapRaw,
+      data.nodemapFiles,
+      data.nodemapDirs,
+      data.listFiles
+    ));
+  }
+  if (Object.keys(data.authoredContent).length > 0) {
+    registry.register(new AuthoredRichMarkdownProvider(data.authoredContent));
+  }
+  const workPRs = data.pullRequests.map((pr) => ({
+    number: pr.number,
+    title: pr.title,
+    body: pr.body,
+    state: pr.state,
+    labels: pr.labels,
+    html_url: pr.html_url,
+    created_at: pr.created_at,
+    updated_at: pr.updated_at,
+    ...pr.head_branch !== void 0 ? { head_branch: pr.head_branch } : {},
+    ...pr.user !== void 0 ? { user: pr.user } : {}
+  }));
+  registry.register(new WorkProvider(
+    data.issues,
+    workPRs,
+    data.commits,
+    data.branches,
+    data.repoMetadata,
+    data.releases
+  ));
+  registry.register(new PersonProvider(
+    data.issues,
+    data.pullRequests.map((pr) => ({
+      number: pr.number,
+      title: pr.title,
+      state: pr.state,
+      html_url: pr.html_url,
+      ...pr.user !== void 0 ? { user: pr.user } : {},
+      ...pr.assignees !== void 0 ? { assignees: pr.assignees } : {}
+    }))
+  ));
+  if (Object.keys(data.structuralFiles).length > 0) {
+    registry.register(new StructuralProvider(data.structuralFiles, data.structuredNodeMapRaw));
+  }
+  registry.register(new ContentModelProvider(data.contentModel));
+}
+async function loadKnowledgeBase(arg1, arg2, arg3, arg4) {
+  if (isRepoSource(arg1)) {
+    return loadFromSource(arg1, arg2, arg3, arg4);
+  }
+  const config = arg1;
+  const options = arg2 ?? {};
+  const source = options.source ?? await defaultSourceFor(config);
+  const positionalOptions = {};
+  if (options.importBaseUrl !== void 0) positionalOptions.importBaseUrl = options.importBaseUrl;
+  if (options.graphStore !== void 0) positionalOptions.graphStore = options.graphStore;
+  const { graph } = await loadFromSource(source, config, options.env, positionalOptions);
+  return graph;
+}
+function isRepoSource(value) {
+  return typeof value.getRepoData === "function";
+}
+async function defaultSourceFor(config) {
+  const { GitHubApiSource } = await import('./github-api-source-KV5HZARH.js');
+  return new GitHubApiSource(config.source);
+}
+async function loadFromSource(source, config, env, options) {
+  const data = await source.getRepoData();
+  const registry = new ProviderRegistry();
+  registerProviders(registry, data);
+  if (config.providers && config.providers.length > 0) {
+    const { loadExternalProviders: loadExternalProviders2 } = await import('./plugin-loader-K4VU6ODV.js');
+    const externals = await loadExternalProviders2(
+      config.providers,
+      options?.importBaseUrl !== void 0 ? { importBaseUrl: options.importBaseUrl } : void 0
+    );
+    for (const p of externals) registry.register(p);
+  }
+  const storeOptions = resolveGraphStoreOptions(env);
+  if (storeOptions.mode === "sqlite") {
+    const [
+      { SQLiteGraphStore },
+      { orchestrateWithProviderResultStore }
+    ] = await Promise.all([
+      import('./sqlite-graph-store-NH2NHL2B.js'),
+      import('./store-orchestrator-337XWIXO.js')
+    ]);
+    const store = await SQLiteGraphStore.create(options?.graphStore?.byteStore, options?.graphStore?.locateFile);
+    const graph2 = await orchestrateWithProviderResultStore(
+      registry,
+      config,
+      { readme: data.readme },
+      store,
+      (providerId, previousContentHash) => buildProviderResultCacheKey(source, config, data, providerId, previousContentHash)
+    );
+    return { graph: graph2, config };
+  }
+  const graph = await orchestrateWithTransforms(registry, config, { readme: data.readme });
+  return { graph, config };
+}
+function parseContentFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) return { meta: {}, body: raw };
+  try {
+    const parsed = yaml.parse(match[1]);
+    return { meta: parsed ?? {}, body: match[2] ?? "" };
+  } catch {
+    return { meta: {}, body: raw };
+  }
+}
+function stripCode(body) {
+  let stripped = body.replace(/```[\s\S]*?```/g, "");
+  stripped = stripped.replace(/`[^`]+`/g, "");
+  return stripped;
+}
+function extractInlineLinks(body) {
+  const clean = stripCode(body);
+  const links = [];
+  const re = /\[([^\]]*)\]\(([^)]+)\)/g;
+  let m;
+  while ((m = re.exec(clean)) !== null) {
+    const target = m[2];
+    if (target.startsWith("http://") || target.startsWith("https://")) continue;
+    if (target.startsWith("#")) continue;
+    if (target.startsWith("mailto:")) continue;
+    links.push(target);
+  }
+  return links;
+}
+function parseAuthoredEntries(authoredContent) {
+  const entries = [];
+  for (const [path, raw] of Object.entries(authoredContent)) {
+    const { meta, body } = parseContentFrontmatter(raw);
+    const id = typeof meta.id === "string" ? meta.id : void 0;
+    if (!id) continue;
+    entries.push({
+      path,
+      id,
+      title: typeof meta.title === "string" ? meta.title : id,
+      cluster: typeof meta.cluster === "string" ? meta.cluster : null,
+      body,
+      links: extractInlineLinks(body)
+    });
+  }
+  return entries;
+}
+function parseConfigClusters(configRaw) {
+  if (!configRaw) return {};
+  try {
+    const parsed = yaml.parse(configRaw);
+    return parsed?.clusters ?? {};
+  } catch {
+    return {};
+  }
+}
+
+// src/validate-graph.ts
+function parseNodemap(raw) {
+  try {
+    return yaml.parse(raw) ?? null;
+  } catch {
+    return null;
+  }
+}
+function validateGraph(input) {
+  const entries = parseAuthoredEntries(input.authoredContent);
+  const definedClusters = new Set(Object.keys(parseConfigClusters(input.configRaw)));
+  const issueCount = input.issues?.length ?? 0;
+  const nodeIds = new Set(entries.map((e) => e.id));
+  const findings = [];
+  for (const entry of entries) {
+    for (const target of entry.links) {
+      if (nodeIds.has(target)) continue;
+      const isGithubRef = target.startsWith("issue-") || target.startsWith("pr-");
+      if (isGithubRef && issueCount === 0) {
+        findings.push({
+          rule: "missing-github-link",
+          severity: "warning",
+          message: `${entry.id} \u2192 ${target} (no GitHub data available)`,
+          nodeId: entry.id,
+          target
+        });
+      } else {
+        findings.push({
+          rule: "broken-inline-link",
+          severity: "error",
+          message: `${entry.id} \u2192 ${target}`,
+          nodeId: entry.id,
+          target
+        });
+      }
+    }
+  }
+  const idCounts = /* @__PURE__ */ new Map();
+  for (const entry of entries) idCounts.set(entry.id, (idCounts.get(entry.id) ?? 0) + 1);
+  for (const [id, count] of idCounts) {
+    if (count > 1) {
+      findings.push({
+        rule: "duplicate-id",
+        severity: "error",
+        message: `duplicate ID "${id}" (${count} files)`,
+        nodeId: id
+      });
+    }
+  }
+  const incomingCount = /* @__PURE__ */ new Map();
+  for (const entry of entries) incomingCount.set(entry.id, 0);
+  for (const entry of entries) {
+    for (const target of entry.links) {
+      if (incomingCount.has(target)) incomingCount.set(target, incomingCount.get(target) + 1);
+    }
+  }
+  for (const [id, count] of incomingCount) {
+    if (count === 0) {
+      findings.push({
+        rule: "orphan-node",
+        severity: "warning",
+        message: `"${id}" has no incoming links`,
+        nodeId: id
+      });
+    }
+  }
+  for (const entry of entries) {
+    if (entry.cluster && !definedClusters.has(entry.cluster)) {
+      findings.push({
+        rule: "invalid-cluster",
+        severity: "error",
+        message: `"${entry.id}" \u2192 cluster "${entry.cluster}"`,
+        nodeId: entry.id,
+        target: entry.cluster
+      });
+    }
+  }
+  if (input.nodemapRaw) {
+    const nodemap = parseNodemap(input.nodemapRaw);
+    const knownPaths = new Set(Object.keys(input.authoredContent));
+    for (const item of input.tree ?? []) knownPaths.add(item.path);
+    for (const node of nodemap?.nodes ?? []) {
+      const candidates = [];
+      if (node.file) candidates.push(node.file);
+      if (node.directory) candidates.push(node.directory);
+      if (node.files) candidates.push(...node.files);
+      for (const path of candidates) {
+        if (!knownPaths.has(path)) {
+          findings.push({
+            rule: "missing-nodemap-path",
+            severity: "error",
+            message: `"${node.id}" \u2192 ${path}`,
+            nodeId: node.id,
+            target: path
+          });
+        }
+      }
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.body.trim()) {
+      findings.push({
+        rule: "empty-content",
+        severity: "warning",
+        message: `"${entry.id}" has empty content`,
+        nodeId: entry.id
+      });
+    }
+  }
+  const errorCount = findings.filter((f) => f.severity === "error").length;
+  const warningCount = findings.filter((f) => f.severity === "warning").length;
+  return {
+    ok: errorCount === 0,
+    errorCount,
+    warningCount,
+    findings,
+    summary: { contentCount: entries.length, issueCount }
+  };
+}
+
+// src/assess-graph.ts
+var LIMITS = {
+  nodesPerView: 40,
+  edgesPerView: 80,
+  maxClusters: 8,
+  highOutDegree: 15
+};
+var MIN_SCORES = {
+  connectivity: 50,
+  clusterBalance: 30,
+  density: 30,
+  bidirectionality: 20,
+  contentDepth: 60
+};
+function clamp100(v) {
+  return Math.max(0, Math.min(100, Math.round(v)));
+}
+function bfsDistances(adjacency, startId) {
+  const distances = /* @__PURE__ */ new Map([[startId, 0]]);
+  const queue = [startId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const d = distances.get(current);
+    for (const neighbour of adjacency.get(current) ?? []) {
+      if (!distances.has(neighbour)) {
+        distances.set(neighbour, d + 1);
+        queue.push(neighbour);
+      }
+    }
+  }
+  return distances;
+}
+function assessGraph(input, options = {}) {
+  const entries = parseAuthoredEntries(input.authoredContent);
+  const nodeIds = new Set(entries.map((e) => e.id));
+  const edges = [];
+  for (const entry of entries) {
+    for (const target of entry.links) {
+      if (nodeIds.has(target)) edges.push({ from: entry.id, to: target });
+    }
+  }
+  const clusterMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.cluster) {
+      if (!clusterMap.has(entry.cluster)) clusterMap.set(entry.cluster, []);
+      clusterMap.get(entry.cluster).push(entry.id);
+    }
+  }
+  const nodeCount = entries.length;
+  const edgeCount = edges.length;
+  const clusterCount = clusterMap.size;
+  const outDegree = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    outDegree.set(id, 0);
+    inDegree.set(id, 0);
+    adjacency.set(id, /* @__PURE__ */ new Set());
+  }
+  for (const e of edges) {
+    outDegree.set(e.from, (outDegree.get(e.from) ?? 0) + 1);
+    inDegree.set(e.to, (inDegree.get(e.to) ?? 0) + 1);
+    adjacency.get(e.from).add(e.to);
+    adjacency.get(e.to).add(e.from);
+  }
+  const nodeCountConstraint = {
+    value: nodeCount,
+    limit: LIMITS.nodesPerView,
+    ok: nodeCount <= LIMITS.nodesPerView
+  };
+  const edgeCountConstraint = {
+    value: edgeCount,
+    limit: LIMITS.edgesPerView,
+    ok: edgeCount <= LIMITS.edgesPerView
+  };
+  const clusterCountConstraint = {
+    value: clusterCount,
+    limit: LIMITS.maxClusters,
+    ok: clusterCount <= LIMITS.maxClusters
+  };
+  const orphans = [];
+  for (const entry of entries) {
+    if ((inDegree.get(entry.id) ?? 0) === 0) orphans.push(entry.id);
+  }
+  let hubId = entries[0]?.id ?? null;
+  let hubDegree = 0;
+  for (const entry of entries) {
+    const total = (outDegree.get(entry.id) ?? 0) + (inDegree.get(entry.id) ?? 0);
+    if (total > hubDegree) {
+      hubDegree = total;
+      hubId = entry.id;
+    }
+  }
+  let maxHops = 0;
+  const unreachable = [];
+  const distances = hubId !== null ? bfsDistances(adjacency, hubId) : /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    if (!distances.has(id)) unreachable.push(id);
+    else maxHops = Math.max(maxHops, distances.get(id));
+  }
+  const avgLinksPerNode = nodeCount > 0 ? edgeCount / nodeCount : 0;
+  let connectivityScore;
+  if (avgLinksPerNode >= 4 && avgLinksPerNode <= 8) {
+    connectivityScore = 100;
+  } else if (avgLinksPerNode < 4) {
+    connectivityScore = clamp100(avgLinksPerNode / 4 * 100);
+  } else {
+    connectivityScore = clamp100(100 - (avgLinksPerNode - 8) / 8 * 50);
+  }
+  const clusterSizes = [...clusterMap.values()].map((members) => members.length);
+  const clusterBalanceApplicable = clusterSizes.length > 1;
+  let clusterBalanceScore = 100;
+  let clusterStdDev = null;
+  if (clusterBalanceApplicable) {
+    const mean = clusterSizes.reduce((a, b) => a + b, 0) / clusterSizes.length;
+    const variance = clusterSizes.reduce((s, v) => s + (v - mean) ** 2, 0) / clusterSizes.length;
+    clusterStdDev = Math.sqrt(variance);
+    clusterBalanceScore = clamp100(100 - clusterStdDev * 15);
+  }
+  const maxEdges = nodeCount > 1 ? nodeCount * (nodeCount - 1) / 2 : 1;
+  const density = edgeCount / maxEdges;
+  let densityScore;
+  if (density >= 0.1 && density <= 0.3) {
+    densityScore = 100;
+  } else if (density < 0.1) {
+    densityScore = clamp100(density / 0.1 * 100);
+  } else {
+    densityScore = clamp100(100 - (density - 0.3) / 0.7 * 100);
+  }
+  const edgeSet = new Set(edges.map((e) => `${e.from}\u2192${e.to}`));
+  let reciprocalCount = 0;
+  for (const e of edges) {
+    if (edgeSet.has(`${e.to}\u2192${e.from}`)) reciprocalCount++;
+  }
+  const bidirectionalPct = edgeCount > 0 ? reciprocalCount / edgeCount * 100 : 0;
+  const bidirectionalityScore = clamp100(bidirectionalPct);
+  const avgContentLength = nodeCount > 0 ? entries.reduce((sum, e) => sum + e.body.length, 0) / nodeCount : 0;
+  const contentDepthScore = clamp100(avgContentLength / 1e3 * 100);
+  const scores = {
+    connectivity: connectivityScore,
+    clusterBalance: clusterBalanceScore,
+    density: densityScore,
+    bidirectionality: bidirectionalityScore,
+    contentDepth: contentDepthScore
+  };
+  const suggestions = [];
+  for (const id of orphans) {
+    suggestions.push(`Node "${id}" has 0 incoming links \u2014 add a reference from a parent node`);
+  }
+  for (const [cluster, members] of clusterMap) {
+    if (members.length > LIMITS.maxClusters + 1) {
+      suggestions.push(`Cluster "${cluster}" has ${members.length} nodes \u2014 consider splitting into sub-clusters`);
+    }
+  }
+  for (const entry of entries) {
+    const out = outDegree.get(entry.id) ?? 0;
+    if (out >= LIMITS.highOutDegree) {
+      suggestions.push(`Node "${entry.id}" has ${out} outgoing links \u2014 consider splitting into focused sub-nodes`);
+    }
+  }
+  const titleMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const t = (entry.title || "").toLowerCase();
+    if (!titleMap.has(t)) titleMap.set(t, []);
+    titleMap.get(t).push(entry.id);
+  }
+  for (const [title, ids] of titleMap) {
+    if (ids.length > 1) {
+      suggestions.push(`Nodes ${ids.join(" and ")} have identical title "${title}" \u2014 possible duplicate`);
+    }
+  }
+  if (edgeCount > LIMITS.edgesPerView) {
+    suggestions.push(`Edge count ${edgeCount} exceeds ${LIMITS.edgesPerView}-edge readability limit \u2014 use layer views`);
+  }
+  if (nodeCount > LIMITS.nodesPerView) {
+    suggestions.push(`Node count ${nodeCount} exceeds ${LIMITS.nodesPerView}-node readability limit \u2014 use layer views`);
+  }
+  const result = {
+    summary: { nodeCount, edgeCount, clusterCount },
+    constraints: {
+      nodeCount: nodeCountConstraint,
+      edgeCount: edgeCountConstraint,
+      clusterCount: clusterCountConstraint,
+      orphanNodes: orphans,
+      hubReachability: { hubId, maxHops, unreachable }
+    },
+    scores,
+    scoreDetails: {
+      avgLinksPerNode,
+      clusterSizes,
+      clusterStdDev,
+      clusterBalanceApplicable,
+      density,
+      bidirectionalPct,
+      avgContentLength
+    },
+    suggestions
+  };
+  if (options.gate) {
+    const failures = [];
+    for (const metric of Object.keys(MIN_SCORES)) {
+      const minimum = MIN_SCORES[metric];
+      const actual = scores[metric];
+      if (actual < minimum) failures.push({ metric, actual, minimum });
+    }
+    result.gate = { pass: failures.length === 0, failures };
+  }
+  return result;
+}
+
+// src/catalogue/derive-needs.ts
+var AUTHORED_FRONTMATTER = /^authored:\s*true/m;
+function toDeriveNeedsNode(node) {
+  const out = { id: node.id };
+  if (node.title !== void 0) out.title = node.title;
+  if (node.cluster !== void 0) out.cluster = node.cluster;
+  if (node.file !== void 0) out.file = node.file;
+  if (node.prompt !== void 0) out.prompt = node.prompt;
+  if (node.edgeHints !== void 0) out.edgeHints = node.edgeHints;
+  return out;
+}
+function deriveNeeds(catalogue, contentFiles) {
+  const nodes = catalogue.nodes ?? [];
+  const authored = [];
+  const needsGeneration = [];
+  for (const node of nodes) {
+    if (node.authored) {
+      authored.push(node);
+      continue;
+    }
+    if (node.derived) {
+      const raw = contentFiles[node.id];
+      if (raw !== void 0 && AUTHORED_FRONTMATTER.test(raw)) {
+        authored.push(node);
+        continue;
+      }
+      needsGeneration.push(node);
+    }
+  }
+  return {
+    total: nodes.length,
+    authored: authored.length,
+    derived: needsGeneration.length,
+    nodes: needsGeneration.map(toDeriveNeedsNode)
+  };
+}
+
+// src/catalogue/compare-content.ts
+var MARKDOWN_LINK = /\[([^\]]+)\]\(([^)]+)\)/g;
+var CLUSTER_FRONTMATTER = /^cluster:\s*(.+)$/m;
+var LINK_DIFF_THRESHOLD = 3;
+function compareContent(catalogue, contentFiles) {
+  const nodes = catalogue.nodes ?? [];
+  const contentIds = Object.keys(contentFiles);
+  const catalogueIds = /* @__PURE__ */ new Set();
+  const authoredNodes = [];
+  const derivedCurrent = [];
+  const missingNodes = [];
+  const clusterChanges = [];
+  const linkDiffs = [];
+  for (const node of nodes) {
+    catalogueIds.add(node.id);
+    const raw = contentFiles[node.id];
+    const fileExists = raw !== void 0;
+    if (node.authored) {
+      if (fileExists) {
+        authoredNodes.push(node);
+      } else {
+        missingNodes.push(node);
+      }
+      continue;
+    }
+    if (node.derived) {
+      if (fileExists) {
+        derivedCurrent.push(node);
+        const clusterMatch = raw.match(CLUSTER_FRONTMATTER);
+        const fileCluster = clusterMatch?.[1]?.trim();
+        if (fileCluster !== void 0 && fileCluster !== node.cluster) {
+          clusterChanges.push({ id: node.id, from: fileCluster, to: String(node.cluster ?? "") });
+        }
+        const hintCount = (node.edgeHints ?? []).length;
+        const linkMatches = raw.match(MARKDOWN_LINK) ?? [];
+        const diff = Math.abs(hintCount - linkMatches.length);
+        if (diff > LINK_DIFF_THRESHOLD) {
+          linkDiffs.push({ id: node.id, catalogue: hintCount, file: linkMatches.length });
+        }
+      } else {
+        missingNodes.push(node);
+      }
+    }
+  }
+  const extraFiles = contentIds.filter((id) => !catalogueIds.has(id) && id !== "catalogue");
+  return {
+    totalNodes: nodes.length,
+    totalContentFiles: contentIds.length,
+    authoredNodes,
+    derivedCurrent,
+    missingNodes,
+    extraFiles,
+    clusterChanges,
+    linkDiffs
+  };
+}
+
+// src/catalogue/enrich-from-manifest.ts
+var SNIPPET_LENGTH = 200;
+var MAX_RELATED_ISSUES = 5;
+var MAX_RELATED_PRS = 5;
+var MAX_RECENT_COMMITS = 8;
+var MIN_TITLE_LENGTH_FOR_COMMIT_MATCH = 5;
+function fileBaseName(file) {
+  const slash = Math.max(file.lastIndexOf("/"), file.lastIndexOf("\\"));
+  const base = slash >= 0 ? file.slice(slash + 1) : file;
+  return base.replace(/\.\w+$/, "");
+}
+function snippetOf(body) {
+  return (body ?? "").substring(0, SNIPPET_LENGTH).replace(/\n/g, " ");
+}
+function enrichFromManifest(catalogue, manifest) {
+  const issues = manifest.issues ?? [];
+  const prs = manifest.pullRequests ?? [];
+  const commits = manifest.commits ?? [];
+  const enrichedNodes = (catalogue.nodes ?? []).map((node) => {
+    const file = node.file ?? "";
+    const fileBase = fileBaseName(file);
+    const titleLower = (node.title ?? "").toLowerCase();
+    const idLower = (node.id ?? "").toLowerCase();
+    const relatedIssues = [];
+    for (const iss of issues) {
+      const body = (iss.body ?? "").toLowerCase();
+      const title = (iss.title ?? "").toLowerCase();
+      if (file && (body.includes(file) || body.includes(fileBase)) || titleLower && (body.includes(titleLower) || title.includes(titleLower)) || idLower && body.includes(idLower)) {
+        relatedIssues.push({ number: iss.number, title: iss.title, state: iss.state, snippet: snippetOf(iss.body) });
+      }
+    }
+    const relatedPRs = [];
+    for (const pr of prs) {
+      const body = (pr.body ?? "").toLowerCase();
+      const title = (pr.title ?? "").toLowerCase();
+      if (file && (body.includes(file) || body.includes(fileBase)) || titleLower && (body.includes(titleLower) || title.includes(titleLower))) {
+        relatedPRs.push({ number: pr.number, title: pr.title, state: pr.state, snippet: snippetOf(pr.body) });
+      }
+    }
+    const recentCommits = [];
+    for (const c of commits) {
+      const msg = (c.commit?.message ?? "").toLowerCase();
+      if (file && msg.includes(fileBase) || titleLower.length > MIN_TITLE_LENGTH_FOR_COMMIT_MATCH && msg.includes(titleLower)) {
+        recentCommits.push({ sha: c.sha?.substring(0, 7), message: c.commit?.message?.split("\n")[0] ?? "" });
+      }
+    }
+    return {
+      ...node,
+      relatedIssues: relatedIssues.slice(0, MAX_RELATED_ISSUES),
+      relatedPRs: relatedPRs.slice(0, MAX_RELATED_PRS),
+      recentCommits: recentCommits.slice(0, MAX_RECENT_COMMITS)
+    };
+  });
+  let nodesWithIssues = 0;
+  let nodesWithPRs = 0;
+  let nodesWithCommits = 0;
+  for (const n of enrichedNodes) {
+    if (n.relatedIssues.length > 0) nodesWithIssues++;
+    if (n.relatedPRs.length > 0) nodesWithPRs++;
+    if (n.recentCommits.length > 0) nodesWithCommits++;
+  }
+  return {
+    catalogue: { ...catalogue, nodes: enrichedNodes },
+    summary: {
+      issueCount: issues.length,
+      prCount: prs.length,
+      commitCount: commits.length,
+      totalNodes: enrichedNodes.length,
+      nodesWithIssues,
+      nodesWithPRs,
+      nodesWithCommits
+    }
+  };
+}
+
+export { AuthoredProvider, AuthoredRichMarkdownProvider, CONTENT_MODEL_KINDS, CONTENT_MODEL_PROVIDER, ContentModelProvider, FilesProvider, PersonProvider, ProviderRegistry, SCHEMA_PATHS, StructuralProvider, WorkProvider, adaptIngestedNode, applyStructuredNodeMap, assessGraph, buildContentModel, buildEditUrl, buildHandoffUrl, buildNewFileUrl, buildSourceEditHandoff, buildStructuralFileNode, buildUnifiedDiff, buildUrn, canEditSource, canonicalKind, collectProviderNodes, compareContent, deriveNeeds, encodeRepoPath, enrichFromManifest, findNodes, getConvention, getNode, hasContentModelSource, inferStructuredNode, isOrgScoped, lifecycleBand, loadKnowledgeBase, neighbors, normalizeNewlines, orchestrate, orchestrateWithTransforms, parseCodeowners, parseStructuredContent, parseStructuredNodeMap, patchFilename, readContentModelSchema, reconstructSource, registerContentModelTypes, registerProviders, registerStructuralTypes, related, repoCoordsFromConfig, resolveCurie, resolveSourceFile, shortestPath, slugify, subgraph, urnLocalId, validateGraph, validateSourceContent };