@tangle-network/agent-knowledge 1.12.1 → 2.0.0

package/dist/chunk-W6VWYTNH.js

@@ -1,958 +0,0 @@
-import {
-  searchKnowledge
-} from "./chunk-DQ3PDMDP.js";
-import {
-  sha256,
-  slugify,
-  stableId
-} from "./chunk-YMKHCTS2.js";
-
-// src/adapters.ts
-var textSourceAdapter = {
-  id: "text",
-  canLoad: (input) => Boolean(input.text) || /\.(md|txt|json|csv)$/i.test(input.uri),
-  load: (input) => ({
-    title: input.uri.split("/").pop(),
-    mediaType: mediaTypeFor(input.uri),
-    text: decodeText(input),
-    anchors: anchorsForText(input.uri, decodeText(input)),
-    metadata: input.metadata
-  })
-};
-function mediaTypeFor(uri) {
-  const lower = uri.toLowerCase();
-  if (lower.endsWith(".md")) return "text/markdown";
-  if (lower.endsWith(".txt")) return "text/plain";
-  if (lower.endsWith(".json")) return "application/json";
-  if (lower.endsWith(".csv")) return "text/csv";
-  if (lower.endsWith(".pdf")) return "application/pdf";
-  return "application/octet-stream";
-}
-function decodeText(input) {
-  return input.text ?? (input.bytes ? new TextDecoder().decode(input.bytes).slice(0, 2e5) : void 0);
-}
-function anchorsForText(uri, text) {
-  if (!text) return [];
-  const lines = text.split("\n");
-  const anchors = [
-    { id: "all", sourceId: "", label: "Full source", lineStart: 1, lineEnd: lines.length }
-  ];
-  for (let i = 0; i < lines.length; i += 50) {
-    anchors.push({
-      id: `l${i + 1}`,
-      sourceId: "",
-      label: `${uri}:${i + 1}`,
-      lineStart: i + 1,
-      lineEnd: Math.min(lines.length, i + 50)
-    });
-  }
-  return anchors;
-}
-
-// src/frontmatter.ts
-function parseFrontmatter(content) {
-  const normalized = content.replace(/\r\n/g, "\n");
-  if (!normalized.startsWith("---\n")) return { frontmatter: {}, body: normalized };
-  const end = normalized.indexOf("\n---", 4);
-  if (end < 0) return { frontmatter: {}, body: normalized };
-  const raw = normalized.slice(4, end);
-  const after = normalized.slice(end).replace(/^\n---\s*\n?/, "");
-  return { frontmatter: parseSimpleYaml(raw), body: after };
-}
-function formatFrontmatter(frontmatter, body) {
-  const lines = Object.entries(frontmatter).filter(([, value]) => value !== void 0).flatMap(([key, value]) => formatYamlField(key, value));
-  if (lines.length === 0) return body;
-  return `---
-${lines.join("\n")}
----
-${body.replace(/^\n+/, "")}`;
-}
-function parseSimpleYaml(raw) {
-  const out = {};
-  const lines = raw.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const scalar = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
-    if (!scalar) continue;
-    const key = scalar[1];
-    const rest = scalar[2].trim();
-    if (rest === "") {
-      const items = [];
-      while (i + 1 < lines.length) {
-        const item = /^\s*-\s*(.+?)\s*$/.exec(lines[i + 1]);
-        if (!item) break;
-        items.push(unquote(item[1]));
-        i++;
-      }
-      out[key] = items;
-      continue;
-    }
-    if (rest.startsWith("[") && rest.endsWith("]")) {
-      out[key] = rest.slice(1, -1).split(",").map((part) => unquote(part.trim())).filter(Boolean);
-    } else if (rest === "true" || rest === "false") {
-      out[key] = rest === "true";
-    } else if (/^-?\d+(?:\.\d+)?$/.test(rest)) {
-      out[key] = Number(rest);
-    } else {
-      out[key] = unquote(rest);
-    }
-  }
-  return out;
-}
-function formatYamlField(key, value) {
-  if (Array.isArray(value)) {
-    return [`${key}:`, ...value.map((item) => `  - ${String(item)}`)];
-  }
-  if (typeof value === "string") return [`${key}: ${value}`];
-  if (typeof value === "number" || typeof value === "boolean") return [`${key}: ${String(value)}`];
-  return [`${key}: ${JSON.stringify(value)}`];
-}
-function unquote(value) {
-  return value.replace(/^['"]|['"]$/g, "");
-}
-
-// src/wikilinks.ts
-var WIKILINK_REGEX = /\[\[([^\]|]+?)(?:\|[^\]]+?)?\]\]/g;
-function extractWikilinks(content) {
-  const links = [];
-  const regex = new RegExp(WIKILINK_REGEX.source, "g");
-  let match;
-  match = regex.exec(content);
-  while (match !== null) {
-    links.push(match[1].trim());
-    match = regex.exec(content);
-  }
-  return [...new Set(links)];
-}
-function normalizeLinkTarget(target) {
-  return target.trim().replace(/\.md$/i, "").toLowerCase().replace(/\s+/g, "-");
-}
-
-// src/graph.ts
-function buildKnowledgeGraph(pages) {
-  const byId = /* @__PURE__ */ new Map();
-  const bySlug = /* @__PURE__ */ new Map();
-  for (const page of pages) {
-    byId.set(page.id, page);
-    bySlug.set(normalizeLinkTarget(page.id), page);
-    bySlug.set(normalizeLinkTarget(page.title), page);
-    bySlug.set(normalizeLinkTarget(page.path.split("/").pop().replace(/\.md$/, "")), page);
-  }
-  const incoming = /* @__PURE__ */ new Map();
-  const outgoing = /* @__PURE__ */ new Map();
-  const edgesByKey = /* @__PURE__ */ new Map();
-  for (const page of pages) {
-    outgoing.set(page.id, 0);
-    incoming.set(page.id, 0);
-  }
-  for (const page of pages) {
-    for (const raw of page.outLinks) {
-      const target = bySlug.get(normalizeLinkTarget(raw));
-      if (!target || target.id === page.id) continue;
-      const key = `${page.id}->${target.id}`;
-      const edge = edgesByKey.get(key);
-      if (edge) edge.weight += 1;
-      else
-        edgesByKey.set(key, {
-          source: page.id,
-          target: target.id,
-          weight: 1,
-          reasons: ["wikilink"]
-        });
-      outgoing.set(page.id, (outgoing.get(page.id) ?? 0) + 1);
-      incoming.set(target.id, (incoming.get(target.id) ?? 0) + 1);
-    }
-  }
-  addSourceOverlapEdges(pages, edgesByKey);
-  const nodes = pages.map((page) => ({
-    id: page.id,
-    title: page.title,
-    path: page.path,
-    tags: page.tags,
-    sourceIds: page.sourceIds,
-    outDegree: outgoing.get(page.id) ?? 0,
-    inDegree: incoming.get(page.id) ?? 0
-  }));
-  return { nodes, edges: [...edgesByKey.values()].sort((a, b) => b.weight - a.weight) };
-}
-function addSourceOverlapEdges(pages, edges) {
-  for (let i = 0; i < pages.length; i++) {
-    for (let j = i + 1; j < pages.length; j++) {
-      const a = pages[i];
-      const b = pages[j];
-      const overlap = a.sourceIds.filter((source) => b.sourceIds.includes(source));
-      if (overlap.length === 0) continue;
-      const key = `${a.id}->${b.id}`;
-      const edge = edges.get(key);
-      if (edge) {
-        edge.weight += overlap.length * 0.5;
-        edge.reasons.push("shared-source");
-      } else {
-        edges.set(key, {
-          source: a.id,
-          target: b.id,
-          weight: overlap.length * 0.5,
-          reasons: ["shared-source"]
-        });
-      }
-    }
-  }
-}
-
-// src/store.ts
-import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
-import { dirname, join, relative } from "path";
-function layoutFor(root) {
-  return {
-    root,
-    knowledgeDir: join(root, "knowledge"),
-    rawSourcesDir: join(root, "raw", "sources"),
-    sourceRegistryPath: join(root, ".agent-knowledge", "sources.json"),
-    indexPath: join(root, "knowledge", "index.md"),
-    logPath: join(root, "knowledge", "log.md"),
-    cacheDir: join(root, ".agent-knowledge")
-  };
-}
-var SCAFFOLD_PAGE_BASENAMES = ["index.md", "log.md"];
-function isScaffoldPath(path) {
-  const normalized = path.replace(/\\/g, "/");
-  for (const basename2 of SCAFFOLD_PAGE_BASENAMES) {
-    if (normalized === `knowledge/${basename2}`) return true;
-    if (normalized.endsWith(`/${basename2}`)) return true;
-  }
-  return false;
-}
-async function initKnowledgeBase(root) {
-  const layout = layoutFor(root);
-  await mkdir(layout.knowledgeDir, { recursive: true });
-  await mkdir(layout.rawSourcesDir, { recursive: true });
-  await mkdir(layout.cacheDir, { recursive: true });
-  await writeIfMissing(layout.indexPath, "# Knowledge Index\n\n");
-  await writeIfMissing(layout.logPath, "# Knowledge Log\n\n");
-  await writeIfMissing(
-    layout.sourceRegistryPath,
-    '{\n  "generatedAt": "1970-01-01T00:00:00.000Z",\n  "sources": []\n}\n'
-  );
-  return layout;
-}
-async function loadKnowledgePages(root) {
-  const layout = layoutFor(root);
-  const files = await listMarkdownFiles(layout.knowledgeDir);
-  const pages = [];
-  for (const file of files) {
-    const rel = relative(root, file).replace(/\\/g, "/");
-    if (isScaffoldPath(rel)) continue;
-    const content = await readFile(file, "utf8");
-    const { frontmatter, body } = parseFrontmatter(content);
-    const title = stringField(frontmatter.title) ?? firstHeading(body) ?? rel.split("/").pop().replace(/\.md$/, "");
-    const sourceIds = arrayField(frontmatter.sources);
-    const tags = arrayField(frontmatter.tags);
-    pages.push({
-      id: stringField(frontmatter.id) ?? slugify(rel.replace(/^knowledge\//, "").replace(/\.md$/, "")),
-      path: rel,
-      title,
-      text: body,
-      frontmatter,
-      sourceIds,
-      tags,
-      outLinks: extractWikilinks(body).map(normalizeLinkTarget)
-    });
-  }
-  pages.sort((a, b) => a.path.localeCompare(b.path));
-  return pages;
-}
-async function writeJson(path, value) {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-async function writeIfMissing(path, content) {
-  try {
-    await stat(path);
-  } catch {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, content, "utf8");
-  }
-}
-async function listMarkdownFiles(root) {
-  try {
-    const entries = await readdir(root, { withFileTypes: true });
-    const out = [];
-    for (const entry of entries) {
-      const full = join(root, entry.name);
-      if (entry.isDirectory()) out.push(...await listMarkdownFiles(full));
-      else if (entry.isFile() && entry.name.endsWith(".md")) out.push(full);
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}
-function stringField(value) {
-  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
-}
-function arrayField(value) {
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-function firstHeading(body) {
-  return /^#\s+(.+)$/m.exec(body)?.[1]?.trim();
-}
-
-// src/sources.ts
-import { copyFile, mkdir as mkdir2, readdir as readdir2, readFile as readFile2, stat as stat2, writeFile as writeFile2 } from "fs/promises";
-import { basename, dirname as dirname2, join as join2, relative as relative2 } from "path";
-async function loadSourceRegistry(root) {
-  const path = sourceRegistryPath(root);
-  try {
-    const parsed = JSON.parse(await readFile2(path, "utf8"));
-    return {
-      generatedAt: typeof parsed.generatedAt === "string" ? parsed.generatedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
-      sources: Array.isArray(parsed.sources) ? parsed.sources : []
-    };
-  } catch {
-    return { generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(), sources: [] };
-  }
-}
-async function writeSourceRegistry(root, registry) {
-  const path = sourceRegistryPath(root);
-  await mkdir2(dirname2(path), { recursive: true });
-  await writeFile2(path, `${JSON.stringify(registry, null, 2)}
-`, "utf8");
-}
-async function addSourcePath(root, sourcePath, options = {}) {
-  const s = await stat2(sourcePath);
-  if (s.isDirectory()) {
-    const out = [];
-    for (const file of await listFiles(sourcePath)) {
-      out.push(...await addSourcePath(root, file, options));
-    }
-    return out;
-  }
-  const layout = layoutFor(root);
-  await mkdir2(layout.rawSourcesDir, { recursive: true });
-  const bytes = await readFile2(sourcePath);
-  const contentHash = sha256(bytes.toString("base64"));
-  const fileName = basename(sourcePath);
-  const adapters = options.adapters ?? [textSourceAdapter];
-  const adapter = adapters.find((candidate) => candidate.canLoad({ uri: sourcePath, bytes }));
-  const loaded = adapter ? await adapter.load({ uri: sourcePath, bytes }) : {};
-  const id = stableId("src", `${contentHash}:${fileName}`);
-  const targetRel = join2(
-    "raw",
-    "sources",
-    `${slugify(fileName.replace(/\.[^.]+$/, ""))}-${contentHash.slice(0, 8)}${ext(fileName)}`
-  ).replace(/\\/g, "/");
-  const targetAbs = join2(root, targetRel);
-  if (options.copyIntoRaw ?? true) {
-    await mkdir2(dirname2(targetAbs), { recursive: true });
-    await copyFile(sourcePath, targetAbs);
-  }
-  const existing = await loadSourceRegistry(root);
-  const record = {
-    id,
-    uri: targetRel,
-    title: loaded.title ?? fileName,
-    mediaType: loaded.mediaType ?? mediaTypeFor2(fileName),
-    contentHash,
-    text: loaded.text ?? textPreview(fileName, bytes),
-    anchors: (loaded.anchors ?? []).map((anchor) => ({ ...anchor, sourceId: id })),
-    createdAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
-    metadata: {
-      ...loaded.metadata ?? {},
-      originalPath: sourcePath,
-      sizeBytes: bytes.length,
-      projectRelativePath: relative2(root, sourcePath).replace(/\\/g, "/")
-    }
-  };
-  const next = {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    sources: [record, ...existing.sources.filter((source) => source.id !== id)]
-  };
-  await writeSourceRegistry(root, next);
-  return [record];
-}
-async function addSourceText(root, input, options = {}) {
-  const text = input.text;
-  const contentHash = sha256(text);
-  const fileName = basename(input.uri) || `${slugify(input.title ?? input.uri)}.txt`;
-  const adapterInput = { uri: input.uri, text, metadata: input.metadata };
-  const adapter = (options.adapters ?? [textSourceAdapter]).find(
-    (candidate) => candidate.canLoad(adapterInput)
-  );
-  const loaded = adapter ? await adapter.load(adapterInput) : {};
-  const id = stableId("src", `${contentHash}:${input.uri}`);
-  const targetRel = join2(
-    "raw",
-    "sources",
-    `${slugify(fileName.replace(/\.[^.]+$/, ""))}-${contentHash.slice(0, 8)}.txt`
-  ).replace(/\\/g, "/");
-  const targetAbs = join2(root, targetRel);
-  await mkdir2(dirname2(targetAbs), { recursive: true });
-  await writeFile2(targetAbs, text.endsWith("\n") ? text : `${text}
-`, "utf8");
-  const existing = await loadSourceRegistry(root);
-  const record = {
-    id,
-    uri: targetRel,
-    title: input.title ?? loaded.title ?? fileName,
-    mediaType: input.mediaType ?? loaded.mediaType ?? "text/plain",
-    contentHash,
-    text: loaded.text ?? text.slice(0, 2e5),
-    anchors: (loaded.anchors ?? []).map((anchor) => ({ ...anchor, sourceId: id })),
-    validUntil: input.validUntil,
-    lastVerifiedAt: input.lastVerifiedAt,
-    createdAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
-    metadata: {
-      ...loaded.metadata ?? {},
-      ...input.metadata ?? {},
-      originalUri: input.uri,
-      sizeBytes: Buffer.byteLength(text, "utf8")
-    }
-  };
-  await writeSourceRegistry(root, {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    sources: [record, ...existing.sources.filter((source) => source.id !== id)]
-  });
-  return record;
-}
-function sourceRegistryPath(root) {
-  return join2(layoutFor(root).cacheDir, "sources.json");
-}
-async function listFiles(root) {
-  const entries = await readdir2(root, { withFileTypes: true });
-  const out = [];
-  for (const entry of entries) {
-    const full = join2(root, entry.name);
-    if (entry.isDirectory()) out.push(...await listFiles(full));
-    else if (entry.isFile()) out.push(full);
-  }
-  return out;
-}
-function ext(fileName) {
-  const idx = fileName.lastIndexOf(".");
-  return idx >= 0 ? fileName.slice(idx) : "";
-}
-function mediaTypeFor2(fileName) {
-  const lower = fileName.toLowerCase();
-  if (lower.endsWith(".md")) return "text/markdown";
-  if (lower.endsWith(".txt")) return "text/plain";
-  if (lower.endsWith(".json")) return "application/json";
-  if (lower.endsWith(".csv")) return "text/csv";
-  if (lower.endsWith(".pdf")) return "application/pdf";
-  return "application/octet-stream";
-}
-function textPreview(fileName, bytes) {
-  const mediaType = mediaTypeFor2(fileName);
-  if (!mediaType.startsWith("text/") && mediaType !== "application/json") return void 0;
-  return bytes.toString("utf8").slice(0, 2e5);
-}
-
-// src/indexer.ts
-import { join as join3 } from "path";
-async function buildKnowledgeIndex(root) {
-  const [pages, sourceRegistry] = await Promise.all([
-    loadKnowledgePages(root),
-    loadSourceRegistry(root)
-  ]);
-  const index = {
-    root,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    sources: sourceRegistry.sources,
-    pages,
-    graph: buildKnowledgeGraph(pages)
-  };
-  return index;
-}
-async function writeKnowledgeIndex(root) {
-  const index = await buildKnowledgeIndex(root);
-  await writeJson(join3(layoutFor(root).cacheDir, "index.json"), index);
-  return index;
-}
-
-// src/lint.ts
-function lintKnowledgeIndex(index) {
-  const findings = [];
-  const byTarget = /* @__PURE__ */ new Set();
-  const titles = /* @__PURE__ */ new Map();
-  const sourceIds = new Set(index.sources.map((source) => source.id));
-  const anchorIds = new Map(
-    index.sources.map((source) => [
-      source.id,
-      new Set((source.anchors ?? []).map((anchor) => anchor.id))
-    ])
-  );
-  const pageIds = /* @__PURE__ */ new Map();
-  const sourceHashes = /* @__PURE__ */ new Map();
-  for (const page of index.pages) {
-    pageIds.set(page.id, [...pageIds.get(page.id) ?? [], page.path]);
-    byTarget.add(normalizeLinkTarget(page.id));
-    byTarget.add(normalizeLinkTarget(page.title));
-    byTarget.add(normalizeLinkTarget(page.path.split("/").pop().replace(/\.md$/, "")));
-    const titleKey = page.title.toLowerCase();
-    titles.set(titleKey, [...titles.get(titleKey) ?? [], page.path]);
-  }
-  for (const source of index.sources) {
-    sourceHashes.set(source.contentHash, [
-      ...sourceHashes.get(source.contentHash) ?? [],
-      source.id
-    ]);
-  }
-  const inbound = /* @__PURE__ */ new Map();
-  for (const page of index.pages) inbound.set(page.id, 0);
-  for (const page of index.pages) {
-    if (page.outLinks.length === 0 && !isScaffoldPath(page.path)) {
-      findings.push({
-        type: "no-outlinks",
-        severity: "info",
-        page: page.path,
-        message: "Page has no wikilinks to other knowledge pages."
-      });
-    }
-    for (const link of page.outLinks) {
-      if (!byTarget.has(normalizeLinkTarget(link))) {
-        findings.push({
-          type: "broken-link",
-          severity: "warning",
-          page: page.path,
-          message: `Broken wikilink [[${link}]].`
-        });
-      }
-    }
-  }
-  for (const edge of index.graph.edges)
-    inbound.set(edge.target, (inbound.get(edge.target) ?? 0) + 1);
-  for (const page of index.pages) {
-    if (!isScaffoldPath(page.path) && (inbound.get(page.id) ?? 0) === 0) {
-      findings.push({
-        type: "orphan",
-        severity: "info",
-        page: page.path,
-        message: "No other page links to this page."
-      });
-    }
-    if (/\bclaim\b/i.test(page.text) && page.sourceIds.length === 0) {
-      findings.push({
-        type: "uncited-claim",
-        severity: "warning",
-        page: page.path,
-        message: "Page appears to contain claims but has no sources frontmatter."
-      });
-    }
-    for (const sourceId of page.sourceIds) {
-      if (!sourceIds.has(sourceId)) {
-        findings.push({
-          type: "missing-source",
-          severity: "error",
-          page: page.path,
-          message: `Page cites unknown source "${sourceId}".`,
-          metadata: { sourceId }
-        });
-      }
-    }
-    for (const ref of extractSourceRefs(page.text)) {
-      if (!sourceIds.has(ref.sourceId)) {
-        findings.push({
-          type: "missing-source",
-          severity: "error",
-          page: page.path,
-          message: `Page cites unknown source "${ref.sourceId}".`,
-          metadata: ref
-        });
-      } else if (ref.anchorId && !anchorIds.get(ref.sourceId)?.has(ref.anchorId)) {
-        findings.push({
-          type: "missing-source",
-          severity: "error",
-          page: page.path,
-          message: `Page cites unknown source anchor "${ref.sourceId}#${ref.anchorId}".`,
-          metadata: ref
-        });
-      }
-    }
-  }
-  for (const [title, paths] of titles) {
-    if (title && paths.length > 1) {
-      findings.push({
-        type: "duplicate-title",
-        severity: "warning",
-        message: `Duplicate title "${title}" in ${paths.join(", ")}.`,
-        metadata: { paths }
-      });
-    }
-  }
-  for (const [id, paths] of pageIds) {
-    if (id && paths.length > 1) {
-      findings.push({
-        type: "duplicate-page-id",
-        severity: "error",
-        message: `Duplicate page id "${id}" in ${paths.join(", ")}.`,
-        metadata: { paths }
-      });
-    }
-  }
-  for (const [hash, ids] of sourceHashes) {
-    if (hash && ids.length > 1) {
-      findings.push({
-        type: "duplicate-source-hash",
-        severity: "warning",
-        message: `Duplicate source content hash across ${ids.join(", ")}.`,
-        metadata: { sourceIds: ids }
-      });
-    }
-  }
-  return findings;
-}
-function extractSourceRefs(text) {
-  const refs = [];
-  const regex = /\[\^([A-Za-z0-9_-]+)(?:#([A-Za-z0-9_.:-]+))?\]/g;
-  let match;
-  match = regex.exec(text);
-  while (match !== null) {
-    refs.push({ sourceId: match[1], anchorId: match[2] });
-    match = regex.exec(text);
-  }
-  return refs;
-}
-
-// src/metadata.ts
-function stringMetadata(metadata, key) {
-  const value = metadata?.[key];
-  return typeof value === "string" ? value : void 0;
-}
-
-// src/inspect.ts
-function inspectKnowledgeIndex(index, options = {}) {
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  const findings = lintKnowledgeIndex(index);
-  const degree = new Map(index.graph.nodes.map((node) => [node.id, node.inDegree + node.outDegree]));
-  const sourceFreshness = index.sources.map((source) => inspectSourceFreshness(source, now));
-  return {
-    pageCount: index.pages.length,
-    sourceCount: index.sources.length,
-    expiredSourceCount: sourceFreshness.filter((source) => source.status === "expired").length,
-    staleSourceCount: sourceFreshness.filter((source) => source.status !== "fresh").length,
-    edgeCount: index.graph.edges.length,
-    findingCount: findings.length,
-    blockingFindingCount: findings.filter((finding) => finding.severity === "error").length,
-    topPages: [...index.pages].sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0)).slice(0, 10).map((page) => ({
-      path: page.path,
-      title: page.title,
-      degree: degree.get(page.id) ?? 0,
-      sources: page.sourceIds.length
-    })),
-    sourceFreshness,
-    findings
-  };
-}
-function inspectSourceFreshness(source, now) {
-  const validUntil = source.validUntil ?? stringMetadata(source.metadata, "validUntil") ?? stringMetadata(source.metadata, "expiresAt");
-  const lastVerifiedAt = source.lastVerifiedAt ?? stringMetadata(source.metadata, "lastVerifiedAt");
-  const status = validUntil && Number.isFinite(Date.parse(validUntil)) ? Date.parse(validUntil) <= now.getTime() ? "expired" : "fresh" : "unknown";
-  return { id: source.id, title: source.title, uri: source.uri, status, validUntil, lastVerifiedAt };
-}
-function explainKnowledgeTarget(index, target) {
-  const page = index.pages.find(
-    (candidate) => candidate.path === target || candidate.id === target || candidate.title.toLowerCase() === target.toLowerCase()
-  );
-  const inbound = page ? index.graph.edges.filter((edge) => edge.target === page.id).map(
-    (edge) => index.pages.find((candidate) => candidate.id === edge.source)?.path ?? edge.source
-  ) : [];
-  const related = page ? searchKnowledge(index, `${page.title} ${page.tags.join(" ")}`, 6).filter((result) => result.page.id !== page.id).map((result) => ({
-    path: result.page.path,
-    title: result.page.title,
-    score: result.score
-  })) : searchKnowledge(index, target, 6).map((result) => ({
-    path: result.page.path,
-    title: result.page.title,
-    score: result.score
-  }));
-  return {
-    target,
-    page,
-    sources: page ? index.sources.filter((source) => page.sourceIds.includes(source.id)).map((source) => ({ id: source.id, title: source.title, uri: source.uri })) : [],
-    links: page?.outLinks ?? [],
-    inbound,
-    related
-  };
-}
-
-// src/write-protocol.ts
-var OPENER_LINE = /^---\s*FILE:\s*(.+?)\s*---\s*$/i;
-var CLOSER_LINE = /^---\s*END\s+FILE\s*---\s*$/i;
-var FENCE_LINE = /^\s{0,3}(```+|~~~+)/;
-function isSafeKnowledgePath(path, allowedPrefixes = ["knowledge/"]) {
-  if (typeof path !== "string" || path.trim() === "") return false;
-  const controlRangeRegex = new RegExp(`[${String.fromCharCode(0)}-${String.fromCharCode(31)}]`);
-  if (controlRangeRegex.test(path)) return false;
-  if (path.startsWith("/") || path.startsWith("\\")) return false;
-  if (/^[a-zA-Z]:/.test(path)) return false;
-  const normalized = path.replace(/\\/g, "/");
-  if (normalized.split("/").some((part) => part === "..")) return false;
-  return allowedPrefixes.some((prefix) => normalized.startsWith(prefix));
-}
-function parseKnowledgeWriteBlocks(text, allowedPrefixes = ["knowledge/"]) {
-  const lines = text.replace(/\r\n/g, "\n").split("\n");
-  const blocks = [];
-  const warnings = [];
-  let i = 0;
-  while (i < lines.length) {
-    const opener = OPENER_LINE.exec(lines[i]);
-    if (!opener) {
-      i++;
-      continue;
-    }
-    const path = opener[1].trim();
-    i++;
-    const contentLines = [];
-    let fenceMarker = null;
-    let fenceLen = 0;
-    let closed = false;
-    while (i < lines.length) {
-      const line = lines[i];
-      const fence = FENCE_LINE.exec(line);
-      if (fence) {
-        const run = fence[1];
-        const char = run[0];
-        if (fenceMarker === null) {
-          fenceMarker = char;
-          fenceLen = run.length;
-        } else if (char === fenceMarker && run.length >= fenceLen) {
-          fenceMarker = null;
-          fenceLen = 0;
-        }
-        contentLines.push(line);
-        i++;
-        continue;
-      }
-      if (fenceMarker === null && CLOSER_LINE.test(line)) {
-        closed = true;
-        i++;
-        break;
-      }
-      contentLines.push(line);
-      i++;
-    }
-    if (!closed) {
-      warnings.push(`FILE block "${path || "(empty)"}" was not closed before end of stream.`);
-      continue;
-    }
-    if (!isSafeKnowledgePath(path, allowedPrefixes)) {
-      warnings.push(`FILE block with unsafe path "${path}" rejected.`);
-      continue;
-    }
-    blocks.push({ path, content: contentLines.join("\n") });
-  }
-  return { blocks, warnings };
-}
-
-// src/proposals.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3, join as join4 } from "path";
-async function applyKnowledgeWriteBlocks(root, proposalText) {
-  const parsed = parseKnowledgeWriteBlocks(proposalText);
-  const written = [];
-  for (const block of parsed.blocks) {
-    const path = join4(root, block.path);
-    await mkdir3(dirname3(path), { recursive: true });
-    await writeFile3(
-      path,
-      block.content.endsWith("\n") ? block.content : `${block.content}
-`,
-      "utf8"
-    );
-    written.push(block.path);
-  }
-  return { written, warnings: parsed.warnings };
-}
-async function applyKnowledgeWriteBlocksFile(root, proposalPath) {
-  return applyKnowledgeWriteBlocks(root, await readFile3(proposalPath, "utf8"));
-}
-
-// src/schemas.ts
-import { z } from "zod";
-var SourceAnchorSchema = z.object({
-  id: z.string().min(1),
-  sourceId: z.string().min(1),
-  label: z.string().optional(),
-  page: z.number().int().positive().optional(),
-  lineStart: z.number().int().positive().optional(),
-  lineEnd: z.number().int().positive().optional(),
-  charStart: z.number().int().nonnegative().optional(),
-  charEnd: z.number().int().nonnegative().optional(),
-  timestampMs: z.number().nonnegative().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-var SourceRecordSchema = z.object({
-  id: z.string().min(1),
-  uri: z.string().min(1),
-  title: z.string().optional(),
-  mediaType: z.string().optional(),
-  contentHash: z.string().min(16),
-  text: z.string().optional(),
-  anchors: z.array(SourceAnchorSchema).optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.string().min(1)
-});
-var KnowledgePageSchema = z.object({
-  id: z.string().min(1),
-  path: z.string().min(1),
-  title: z.string().min(1),
-  text: z.string(),
-  frontmatter: z.record(z.string(), z.unknown()),
-  sourceIds: z.array(z.string()),
-  tags: z.array(z.string()),
-  outLinks: z.array(z.string())
-});
-var KnowledgeGraphNodeSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  path: z.string(),
-  tags: z.array(z.string()),
-  sourceIds: z.array(z.string()),
-  outDegree: z.number().int().nonnegative(),
-  inDegree: z.number().int().nonnegative()
-});
-var KnowledgeGraphEdgeSchema = z.object({
-  source: z.string(),
-  target: z.string(),
-  weight: z.number(),
-  reasons: z.array(z.string())
-});
-var KnowledgeIndexSchema = z.object({
-  root: z.string(),
-  generatedAt: z.string(),
-  sources: z.array(SourceRecordSchema),
-  pages: z.array(KnowledgePageSchema),
-  graph: z.object({
-    nodes: z.array(KnowledgeGraphNodeSchema),
-    edges: z.array(KnowledgeGraphEdgeSchema)
-  })
-});
-var KnowledgeEventSchema = z.object({
-  id: z.string().min(1),
-  type: z.enum([
-    "source.added",
-    "proposal.applied",
-    "index.built",
-    "lint.run",
-    "optimization.run",
-    "release.promoted",
-    "release.rejected"
-  ]),
-  createdAt: z.string().min(1),
-  actor: z.string().optional(),
-  target: z.string().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-var KnowledgeBaseCandidateSchema = z.object({
-  id: z.string().min(1),
-  units: z.array(
-    z.object({
-      id: z.string().min(1),
-      title: z.string().min(1),
-      text: z.string(),
-      claims: z.array(
-        z.object({
-          id: z.string().min(1),
-          text: z.string().min(1),
-          refs: z.array(
-            z.object({
-              sourceId: z.string().min(1),
-              anchorId: z.string().optional(),
-              quote: z.string().optional()
-            })
-          ),
-          confidence: z.number().min(0).max(1).optional(),
-          status: z.enum(["draft", "active", "superseded", "rejected"]).optional(),
-          metadata: z.record(z.string(), z.unknown()).optional()
-        })
-      ).optional(),
-      relations: z.array(
-        z.object({
-          sourceId: z.string(),
-          targetId: z.string(),
-          predicate: z.string(),
-          weight: z.number().optional(),
-          metadata: z.record(z.string(), z.unknown()).optional()
-        })
-      ).optional(),
-      sourceIds: z.array(z.string()).optional(),
-      tags: z.array(z.string()).optional(),
-      metadata: z.record(z.string(), z.unknown()).optional(),
-      updatedAt: z.string().optional()
-    })
-  ),
-  retrievalPolicy: z.string().optional(),
-  synthesisPolicy: z.string().optional(),
-  questionPolicy: z.string().optional(),
-  updatePolicy: z.string().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-
-// src/validate.ts
-function validateKnowledgeIndex(index, options = {}) {
-  const findings = [...lintKnowledgeIndex(index)];
-  const parsed = KnowledgeIndexSchema.safeParse(index);
-  if (!parsed.success) {
-    findings.push({
-      type: "missing-frontmatter",
-      severity: "error",
-      message: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")
-    });
-  }
-  if (options.strict) {
-    for (const page of index.pages) {
-      if (isScaffoldPath(page.path)) continue;
-      if (!page.frontmatter.id || !page.frontmatter.title) {
-        findings.push({
-          type: "missing-frontmatter",
-          severity: "error",
-          page: page.path,
-          message: "Strict mode requires id and title frontmatter."
-        });
-      }
-    }
-  }
-  return { ok: !findings.some((finding) => finding.severity === "error"), findings };
-}
-
-export {
-  textSourceAdapter,
-  mediaTypeFor,
-  stringMetadata,
-  parseFrontmatter,
-  formatFrontmatter,
-  WIKILINK_REGEX,
-  extractWikilinks,
-  normalizeLinkTarget,
-  buildKnowledgeGraph,
-  layoutFor,
-  SCAFFOLD_PAGE_BASENAMES,
-  isScaffoldPath,
-  initKnowledgeBase,
-  loadKnowledgePages,
-  writeJson,
-  loadSourceRegistry,
-  writeSourceRegistry,
-  addSourcePath,
-  addSourceText,
-  sourceRegistryPath,
-  buildKnowledgeIndex,
-  writeKnowledgeIndex,
-  lintKnowledgeIndex,
-  inspectKnowledgeIndex,
-  explainKnowledgeTarget,
-  isSafeKnowledgePath,
-  parseKnowledgeWriteBlocks,
-  applyKnowledgeWriteBlocks,
-  applyKnowledgeWriteBlocksFile,
-  SourceAnchorSchema,
-  SourceRecordSchema,
-  KnowledgePageSchema,
-  KnowledgeGraphNodeSchema,
-  KnowledgeGraphEdgeSchema,
-  KnowledgeIndexSchema,
-  KnowledgeEventSchema,
-  KnowledgeBaseCandidateSchema,
-  validateKnowledgeIndex
-};
-//# sourceMappingURL=chunk-W6VWYTNH.js.map