llm-wiki-compiler 0.7.0 → 0.8.0

package/dist/cli.js

@@ -14,7 +14,8 @@ import { writeFile, rename, readFile, mkdir } from "fs/promises";
 import path from "path";
 import yaml from "js-yaml";
 var CITATION_MARKER_PATTERN = /\^\[([^\]]+)\]/g;
-var SPAN_SUFFIX_PATTERN = /^(?<file>[^:#]+)(?:(?::(?<colonStart>\d+)(?:-(?<colonEnd>\d+))?)|(?:#L(?<hashStart>\d+)(?:-L(?<hashEnd>\d+))?))?$/;
+var SPAN_SUFFIX_PATTERN = /^(?<file>[^:#]+)(?:(?::(?<colonStart>\d+)(?:[,-]\s*(?<colonEnd>\d+))?)|(?:#L(?<hashStart>\d+)(?:-L(?<hashEnd>\d+))?))?$/;
+var COLON_MULTILINE_PATTERN = /^(?<file>[^:#]+):(?<lines>\d+(?:,\s*\d+)+)$/;
 var MIN_LINE_NUMBER = 1;
 var VALID_PROVENANCE_STATES = /* @__PURE__ */ new Set([
   "extracted",
@@ -71,13 +72,31 @@ function extractClaimCitations(body) {
   }
   return citations;
 }
+function splitCitationMarker(inner) {
+  return inner.split(/,(?!\s*\d+\s*(?:,|$))/);
+}
 function parseCitationEntries(inner) {
   const spans = [];
-  for (const part of inner.split(",")) {
+  for (const part of splitCitationMarker(inner)) {
     const trimmed = part.trim();
     if (trimmed.length === 0) continue;
-    const span = parseSpanEntry(trimmed);
-    if (span !== void 0) spans.push(span);
+    spans.push(...parseSpanEntries(trimmed));
+  }
+  return spans;
+}
+function parseSpanEntries(entry) {
+  const multi = COLON_MULTILINE_PATTERN.exec(entry);
+  if (multi?.groups) return parseCommaLines(multi.groups.file, multi.groups.lines);
+  const single = parseSpanEntry(entry);
+  return single !== void 0 ? [single] : [];
+}
+function parseCommaLines(file, linesStr) {
+  const spans = [];
+  for (const token of linesStr.split(/,\s*/)) {
+    const lineNum = Number(token);
+    if (isValidLineRange(lineNum, lineNum)) {
+      spans.push({ file, lines: { start: lineNum, end: lineNum } });
+    }
   }
   return spans;
 }
@@ -284,10 +303,16 @@ function error(text) {
 function source(text) {
   return `${CYAN}${text}${RESET}`;
 }
+var quietMode = false;
+function setQuiet(quiet) {
+  quietMode = quiet;
+}
 function status(icon, message) {
+  if (quietMode) return;
   console.log(`${icon} ${message}`);
 }
 function header(title) {
+  if (quietMode) return;
   console.log(`
 ${BOLD}${title}${RESET}`);
   console.log(dim("\u2500".repeat(Math.min(title.length + 4, 60))));
@@ -458,7 +483,8 @@ var AnthropicProvider = class {
       max_tokens: maxTokens,
       system,
       messages,
-      tools: anthropicTools
+      tools: anthropicTools,
+      tool_choice: { type: "any" }
     });
     const toolBlock = response.content.find((block) => block.type === "tool_use");
     if (toolBlock?.type === "tool_use") {
@@ -702,8 +728,8 @@ function parseVtt(raw, filePath) {
   const lines = raw.split("\n");
   const output = [];
   let inCue = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
+  for (const line2 of lines) {
+    const trimmed = line2.trim();
     if (trimmed === "WEBVTT" || trimmed === "") {
       inCue = false;
       continue;
@@ -723,8 +749,8 @@ function parseVtt(raw, filePath) {
 function parseSrt(raw, filePath) {
   const lines = raw.split("\n");
   const output = [];
-  for (const line of lines) {
-    const trimmed = line.trim();
+  for (const line2 of lines) {
+    const trimmed = line2.trim();
     if (trimmed === "" || SRT_SEQUENCE_PATTERN.test(trimmed)) {
       continue;
     }
@@ -939,9 +965,9 @@ function titleFromFirstUserMessage(turns) {
   const firstUser = turns.find((t) => t.role === "user" && t.content.trim().length > 0);
   return resolveSessionTitle(void 0, firstUser?.content, "Claude Session");
 }
-function parseLine(line) {
+function parseLine(line2) {
   try {
-    return JSON.parse(line);
+    return JSON.parse(line2);
   } catch {
     return null;
   }
@@ -976,8 +1002,8 @@ var claudeAdapter = {
     }
     const turns = [];
     const timestamps = [];
-    for (const [index, line] of lines.entries()) {
-      const event = parseLine(line);
+    for (const [index, line2] of lines.entries()) {
+      const event = parseLine(line2);
       if (event === null) {
         throw new Error(
           `Malformed JSON on line ${index + 1} of Claude session: ${filePath}`
@@ -1009,24 +1035,35 @@ function unixToIso(ts) {
 function extractTurns(mapping) {
   const turns = [];
   for (const node of Object.values(mapping)) {
-    const msg = node.message;
-    if (!msg) continue;
-    const role = msg.author?.role;
-    if (role !== "user" && role !== "assistant") continue;
-    const content = (msg.content?.parts ?? []).join("\n").trim();
-    if (content.length === 0) continue;
-    turns.push({
-      role,
-      content,
-      timestamp: msg.create_time != null ? unixToIso(msg.create_time) : void 0
-    });
+    const turn = nodeToTurn(node);
+    if (turn) turns.push(turn);
   }
-  turns.sort((a, b) => {
-    if (!a.timestamp || !b.timestamp) return 0;
-    return a.timestamp.localeCompare(b.timestamp);
-  });
+  turns.sort(compareTurnsByTimestamp);
   return turns;
 }
+function nodeToTurn(node) {
+  const msg = node.message;
+  if (!msg) return null;
+  const role = normalizeRole(msg.author?.role);
+  if (!role) return null;
+  const content = joinTrimmedParts(msg.content?.parts);
+  if (content.length === 0) return null;
+  return { role, content, timestamp: timestampFromUnix(msg.create_time) };
+}
+function normalizeRole(role) {
+  if (role === "user" || role === "assistant") return role;
+  return null;
+}
+function joinTrimmedParts(parts) {
+  return (parts ?? []).join("\n").trim();
+}
+function timestampFromUnix(ts) {
+  return ts != null ? unixToIso(ts) : void 0;
+}
+function compareTurnsByTimestamp(a, b) {
+  if (!a.timestamp || !b.timestamp) return 0;
+  return a.timestamp.localeCompare(b.timestamp);
+}
 function isCodexExport(value) {
   return Array.isArray(value) && value.length > 0 && typeof value[0].mapping === "object";
 }
@@ -1319,6 +1356,87 @@ async function buildHealthResponse(snapshot) {
   };
 }
 
+// src/viewer/graph.ts
+var DEFAULT_KIND = "concept";
+function resolvePageKind(frontmatter) {
+  return typeof frontmatter.kind === "string" && frontmatter.kind.length > 0 ? frontmatter.kind : DEFAULT_KIND;
+}
+function buildGraphData(pages) {
+  const pageIds = new Set(pages.map((p) => p.id));
+  const edges = buildEdges(pages);
+  const ghostDisplayMap = buildGhostDisplayMap(pages);
+  const inDegreeMap = buildInDegreeMap(edges);
+  const realNodes = pages.map((p) => buildNode(p, pageIds, inDegreeMap));
+  const ghostNodes = buildGhostNodes(edges, pageIds, inDegreeMap, ghostDisplayMap);
+  return { nodes: [...realNodes, ...ghostNodes], edges };
+}
+function buildGhostDisplayMap(pages) {
+  const map = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    for (const { slug, display } of page.danglingLinks ?? []) {
+      const id = ghostId(slug);
+      if (!map.has(id)) map.set(id, display);
+    }
+  }
+  return map;
+}
+var GHOST_DIRECTORY = "concepts";
+function ghostId(slug) {
+  return `${GHOST_DIRECTORY}/${slug}`;
+}
+function buildEdges(pages) {
+  const edges = [];
+  for (const page of pages) {
+    for (const target of page.outgoingLinks) {
+      edges.push({ source: page.id, target });
+    }
+    for (const { slug } of page.danglingLinks ?? []) {
+      edges.push({ source: page.id, target: ghostId(slug) });
+    }
+  }
+  return edges;
+}
+function buildGhostNodes(edges, pageIds, inDegreeMap, displayMap) {
+  const seen = /* @__PURE__ */ new Set();
+  const ghosts = [];
+  for (const { target } of edges) {
+    if (pageIds.has(target) || seen.has(target)) continue;
+    seen.add(target);
+    const [directory, ...rest] = target.split("/");
+    const slug = rest.join("/");
+    ghosts.push({
+      id: target,
+      title: displayMap.get(target) ?? slug,
+      slug,
+      directory,
+      kind: "dangling",
+      degree: inDegreeMap.get(target) ?? 0,
+      isDangling: true
+    });
+  }
+  return ghosts;
+}
+function buildInDegreeMap(edges) {
+  const map = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    map.set(edge.target, (map.get(edge.target) ?? 0) + 1);
+  }
+  return map;
+}
+function buildNode(page, pageIds, inDegreeMap) {
+  const outDegree = page.outgoingLinks.filter((t) => pageIds.has(t)).length;
+  const inDegree = inDegreeMap.get(page.id) ?? 0;
+  const kind = resolvePageKind(page.frontmatter);
+  return {
+    id: page.id,
+    title: page.title,
+    slug: page.slug,
+    directory: page.pageDirectory,
+    kind,
+    degree: outDegree + inDegree
+  };
+}
+
 // src/viewer/shell.ts
 import { readFile as readFile12 } from "fs/promises";
 import path14 from "path";
@@ -1342,7 +1460,7 @@ function substitutePageIndex(template, pages) {
     pageDirectory: page.pageDirectory,
     slug: page.slug,
     title: page.title,
-    kind: typeof page.frontmatter.kind === "string" && page.frontmatter.kind.length > 0 ? page.frontmatter.kind : "concept"
+    kind: resolvePageKind(page.frontmatter)
   }));
   const json = JSON.stringify({ pages: embedded }).replace(/</g, "\\u003c");
   const block = `<script type="application/json" id="page-index">${json}</script>`;
@@ -1471,7 +1589,7 @@ import sanitizeHtml from "sanitize-html";
 // src/wiki/collect.ts
 import { readdir as readdir2, readFile as readFile14, realpath as realpath2 } from "fs/promises";
 import path17 from "path";
-var WIKILINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+var WIKILINK_RE = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
 function extractWikilinkSlugs(body) {
   const slugs = /* @__PURE__ */ new Set();
   WIKILINK_RE.lastIndex = 0;
@@ -1481,6 +1599,23 @@ function extractWikilinkSlugs(body) {
   }
   return [...slugs];
 }
+function extractWikilinkTargets(body) {
+  const seen = /* @__PURE__ */ new Set();
+  const targets = [];
+  WIKILINK_RE.lastIndex = 0;
+  let match;
+  while ((match = WIKILINK_RE.exec(body)) !== null) {
+    const target = match[1].trim();
+    const alias = match[2]?.trim();
+    const slug = slugify(target);
+    const display = alias ?? target;
+    if (!seen.has(slug)) {
+      seen.add(slug);
+      targets.push({ slug, display });
+    }
+  }
+  return targets;
+}
 async function safeRealpath(p) {
   try {
     return await realpath2(p);
@@ -1576,11 +1711,24 @@ function resolveBareSlugList(targets, pages) {
 function decoratePages(raw) {
   const shells = raw.map(buildPageShell);
   for (const page of shells) {
-    const targets = extractWikilinkSlugs(page.body);
-    page.outgoingLinks = resolveBareSlugList(targets, shells);
+    const slugTargets = extractWikilinkSlugs(page.body);
+    const richTargets = extractWikilinkTargets(page.body);
+    page.outgoingLinks = resolveBareSlugList(slugTargets, shells);
+    page.danglingLinks = collectDanglingLinks(richTargets, shells);
   }
   return shells;
 }
+function collectDanglingLinks(targets, pages) {
+  const seen = /* @__PURE__ */ new Set();
+  const dangling = [];
+  for (const t of targets) {
+    if (resolveBareSlug(t.slug, pages) === null && !seen.has(t.slug)) {
+      seen.add(t.slug);
+      dangling.push(t);
+    }
+  }
+  return dangling;
+}
 function buildPageShell(page) {
   const id = `${page.pageDirectory}/${page.slug}`;
   return {
@@ -2041,21 +2189,25 @@ async function routeRegistered(req, res, parsedUrl, snapshot, isLoopback) {
   if (parsedUrl.pathname === "/api/index") return handleApiIndex(res, snapshot, isLoopback);
   if (parsedUrl.pathname === "/api/health") return handleApiHealth(res, snapshot);
   if (parsedUrl.pathname === "/api/search") return handleApiSearch(res, parsedUrl, snapshot);
+  if (parsedUrl.pathname === "/api/graph") return handleApiGraph(res, snapshot);
   if (parsedUrl.pathname.startsWith("/api/page/")) {
     return handleApiPage(res, parsedUrl.pathname, snapshot, isLoopback);
   }
   throw new Error(`route registration drift: no handler for ${parsedUrl.pathname}`);
 }
+var REGISTERED_EXACT_PATHS = /* @__PURE__ */ new Set([
+  "/",
+  "/api/pages",
+  "/api/index",
+  "/api/health",
+  "/api/search",
+  "/api/graph"
+]);
+var REGISTERED_PATH_PREFIXES = ["/assets/", "/api/page/"];
 function isRouteRegistered(method, pathname) {
   if (method !== "GET") return false;
-  if (pathname === "/") return true;
-  if (pathname.startsWith("/assets/")) return true;
-  if (pathname === "/api/pages") return true;
-  if (pathname === "/api/index") return true;
-  if (pathname === "/api/health") return true;
-  if (pathname === "/api/search") return true;
-  if (pathname.startsWith("/api/page/")) return true;
-  return false;
+  if (REGISTERED_EXACT_PATHS.has(pathname)) return true;
+  return REGISTERED_PATH_PREFIXES.some((prefix) => pathname.startsWith(prefix));
 }
 function applySecurityHeaders(res) {
   res.setHeader("Content-Security-Policy", CONTENT_SECURITY_POLICY);
@@ -2143,7 +2295,7 @@ function pageListRow(page) {
     pageDirectory: page.pageDirectory,
     slug: page.slug,
     title: page.title,
-    kind: typeof page.frontmatter.kind === "string" ? page.frontmatter.kind : "concept",
+    kind: resolvePageKind(page.frontmatter),
     summary: typeof page.frontmatter.summary === "string" ? page.frontmatter.summary : "",
     updatedAt: typeof page.frontmatter.updatedAt === "string" ? page.frontmatter.updatedAt : "",
     warnings: page.warnings
@@ -2165,6 +2317,9 @@ function handleApiIndex(res, snapshot, isLoopback) {
     generatedAt: snapshot.generatedAt
   });
 }
+function handleApiGraph(res, snapshot) {
+  writeJson(res, 200, snapshot.graph);
+}
 async function handleApiHealth(res, snapshot) {
   const health = await buildHealthResponse(snapshot);
   writeJson(res, 200, health);
@@ -2427,6 +2582,7 @@ async function buildViewerSnapshot(root) {
   };
   const sourceFileSet = new Set(sourceFilenames);
   const annotatedPages = pages.map((page) => annotateCitationWarnings(page, sourceFileSet));
+  const graph = buildGraphData(annotatedPages);
   return {
     root,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2435,7 +2591,8 @@ async function buildViewerSnapshot(root) {
     index: fullIndex,
     recentPages: buildRecentPages(annotatedPages),
     pages: annotatedPages,
-    sourceFilenames
+    sourceFilenames,
+    graph
   };
 }
 function annotateCitationWarnings(page, sourceFiles) {
@@ -2560,19 +2717,22 @@ function openInBrowser(url) {
 function resolveBindConfig(options) {
   const hostFlag = typeof options.host === "string" && options.host.length > 0;
   const allowLan = options.allowLan === true;
-  if (hostFlag !== allowLan) {
-    throw new Error(
-      "Privacy gate: --host and --allow-lan must be supplied together. Use both to bind beyond loopback, or neither to keep the viewer on 127.0.0.1."
-    );
-  }
+  assertHostAllowLanSymmetry(hostFlag, allowLan);
   const host = hostFlag ? options.host : LOOPBACK_HOST;
-  if (WILDCARD_HOSTS.has(host)) {
-    throw new Error(
-      `--host ${host} is not supported: wildcard binds defeat the viewer's DNS-rebind protection. Use a specific interface IP (e.g. 192.168.1.10) instead.`
-    );
-  }
-  const port = parsePort(options.port);
-  return { host, port };
+  assertHostNotWildcard(host);
+  return { host, port: parsePort(options.port) };
+}
+function assertHostAllowLanSymmetry(hostFlag, allowLan) {
+  if (hostFlag === allowLan) return;
+  throw new Error(
+    "Privacy gate: --host and --allow-lan must be supplied together. Use both to bind beyond loopback, or neither to keep the viewer on 127.0.0.1."
+  );
+}
+function assertHostNotWildcard(host) {
+  if (!WILDCARD_HOSTS.has(host)) return;
+  throw new Error(
+    `--host ${host} is not supported: wildcard binds defeat the viewer's DNS-rebind protection. Use a specific interface IP (e.g. 192.168.1.10) instead.`
+  );
 }
 function buildReadyUrl(host, port) {
   if (host.includes(":")) return `http://[${host}]:${port}`;
@@ -2581,11 +2741,14 @@ function buildReadyUrl(host, port) {
 function parsePort(raw) {
   if (raw === void 0) return 0;
   const value = typeof raw === "number" ? raw : Number(raw);
-  if (!Number.isInteger(value) || value < 0 || value > 65535) {
+  if (!isValidPort(value)) {
     throw new Error(`Invalid --port value: ${raw}`);
   }
   return value;
 }
+function isValidPort(value) {
+  return Number.isInteger(value) && value >= 0 && value <= 65535;
+}
 function registerShutdown(close) {
   const shutdown = async () => {
     try {
@@ -2902,6 +3065,11 @@ function getActiveProviderName() {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+var NON_RETRIABLE_RE = /^4(?!29)\d\d\b/;
+function isNonRetriable(error2) {
+  const msg = error2 instanceof Error ? error2.message : String(error2);
+  return NON_RETRIABLE_RE.test(msg);
+}
 async function callClaude(options) {
   const { system, messages, tools, maxTokens = 4096, stream = false, onToken } = options;
   const provider = getProvider();
@@ -2915,7 +3083,7 @@ async function callClaude(options) {
       }
       return await provider.complete(system, messages, maxTokens);
     } catch (error2) {
-      if (attempt === RETRY_COUNT) throw error2;
+      if (attempt === RETRY_COUNT || isNonRetriable(error2)) throw error2;
       const delayMs = RETRY_BASE_MS * Math.pow(RETRY_MULTIPLIER, attempt);
       const errMsg = error2 instanceof Error ? error2.message : String(error2);
       console.warn(`\u26A0 API call failed (attempt ${attempt + 1}/${RETRY_COUNT + 1}): ${errMsg}`);
@@ -3033,6 +3201,11 @@ function languageDirective() {
   if (!lang) return "";
   return `Write the output in ${lang}.`;
 }
+function applyLanguageOption(lang) {
+  if (lang && lang.trim().length > 0) {
+    process.env.LLMWIKI_OUTPUT_LANG = lang.trim();
+  }
+}
 
 // src/compiler/prompts.ts
 function withLangLine(...lines) {
@@ -3151,16 +3324,17 @@ ${relatedPages}` : "";
     ),
     "",
     "Source attribution: at the end of each prose paragraph, append a citation",
-    "marker showing which source file(s) the paragraph drew from.",
-    "Format: ^[filename.md] for single-source, ^[source-a.md, source-b.md] for multi-source.",
-    "When a single sentence makes a specific factual claim and you can identify the",
-    "exact line range it came from, you may use the claim-level form",
-    "^[filename.md:START-END] (or ^[filename.md#LSTART-LEND]) at the end of that",
-    "sentence \u2014 START and END are 1-indexed line numbers in the source file.",
-    "Paragraph-level citations remain the default; only switch to claim-level form",
-    "when it materially improves verifiability and the line range is unambiguous.",
+    "marker identifying which source file(s) and line range the paragraph drew from.",
+    "PREFERRED format: ^[filename.md:START-END] where START and END are the line numbers",
+    "shown in the numbered source content below (e.g. ' 42 | some text' \u2192 line 42).",
+    "Use this whenever you can identify the specific numbered lines supporting the claim.",
+    "Fallback format: ^[filename.md] when the claim draws from the source broadly and",
+    "no specific line range applies. For multi-source paragraphs: ^[a.md:1-5, b.md:10-12].",
     "Place citations only at the end of prose paragraphs or sentences \u2014 not on",
     "headings, list items, or code blocks.",
+    "Do not cite YAML frontmatter lines (the --- ... --- block at the top of a file) as",
+    "source evidence for substantive claims \u2014 those lines are metadata, not content.",
+    "If a claim relates to a metadata field (e.g. document date or author), leave it uncited.",
     "Source filenames are visible as `--- SOURCE: filename.md ---` headers in the content below.",
     "",
     "If a paragraph is your inference rather than a direct extraction, leave it",
@@ -3349,7 +3523,7 @@ function defaultSchemaInitPath(root) {
 // src/schema/helpers.ts
 import yaml3 from "js-yaml";
 var WIKILINK_PATTERN = /\[\[([^\]]+)\]\]/g;
-function resolvePageKind(rawKind, schema) {
+function resolvePageKind2(rawKind, schema) {
   if (typeof rawKind === "string" && PAGE_KINDS.includes(rawKind)) {
     return rawKind;
   }
@@ -3753,10 +3927,15 @@ function buildBudgetedCombinedContent(concept, slices) {
   );
   return formatSlices(trimmed);
 }
+function numberLines(content) {
+  const lines = content.split("\n");
+  const width = String(lines.length).length;
+  return lines.map((line2, i) => `${String(i + 1).padStart(width)} | ${line2}`).join("\n");
+}
 function formatSlices(slices) {
   return slices.map((s) => `--- SOURCE: ${s.file} ---
 
-${s.content}`).join("\n\n");
+${numberLines(s.content)}`).join("\n\n");
 }
 function warnTruncation(concept, totalRaw, sourceCount, perSource, budget) {
   status(
@@ -4308,15 +4487,16 @@ async function checkBrokenWikilinks(root) {
   const existingSlugs = buildPageSlugSet(pages);
   const results = [];
   for (const page of pages) {
-    for (const { captured, line } of findMatchesInContent(page.content, WIKILINK_PATTERN2)) {
-      const linkSlug = slugify(captured);
+    for (const { captured, line: line2 } of findMatchesInContent(page.content, WIKILINK_PATTERN2)) {
+      const linkTarget = captured.split("|")[0].trim();
+      const linkSlug = slugify(linkTarget);
       if (!existingSlugs.has(linkSlug)) {
         results.push({
           rule: "broken-wikilink",
           severity: "error",
           file: page.filePath,
           message: `Broken wikilink [[${captured}]] \u2014 no matching page found`,
-          line
+          line: line2
         });
       }
     }
@@ -4474,7 +4654,7 @@ function countUncitedProseParagraphs(body) {
   }
   return count;
 }
-var COLON_SPAN_PATTERN = /^[^:#]+:(\d+)(?:-(\d+))?$/;
+var COLON_SPAN_PATTERN = /^[^:#]+:(\d+)(?:[,-]\s*(\d+))?$/;
 var HASH_SPAN_PATTERN = /^[^:#]+#L(\d+)(?:-L(\d+))?$/;
 async function checkSchemaCrossLinks(root, schema) {
   const pages = await collectAllPages(root);
@@ -4486,7 +4666,7 @@ async function checkSchemaCrossLinks(root, schema) {
 }
 function checkPageCrossLinks(content, filePath, schema) {
   const { meta, body } = parseFrontmatter(content);
-  const kind = resolvePageKind(meta.kind, schema);
+  const kind = resolvePageKind2(meta.kind, schema);
   const rule = schema.kinds[kind];
   if (rule.minWikilinks <= 0) return [];
   const linkCount = countWikilinks(body);
@@ -4537,13 +4717,13 @@ async function checkBrokenCitations(root) {
 }
 async function checkPageBrokenCitations(content, filePath, sourcesDir, lineCountCache = /* @__PURE__ */ new Map()) {
   const results = [];
-  for (const { captured, line } of findMatchesInContent(content, CITATION_PATTERN)) {
-    await collectBrokenForMarker(captured, line, filePath, sourcesDir, lineCountCache, results);
+  for (const { captured, line: line2 } of findMatchesInContent(content, CITATION_PATTERN)) {
+    await collectBrokenForMarker(captured, line2, filePath, sourcesDir, lineCountCache, results);
   }
   return results;
 }
-async function collectBrokenForMarker(captured, line, pageFile, sourcesDir, lineCountCache, out) {
-  for (const part of captured.split(",")) {
+async function collectBrokenForMarker(captured, line2, pageFile, sourcesDir, lineCountCache, out) {
+  for (const part of splitCitationMarker(captured)) {
     const trimmed = part.trim();
     if (trimmed.length === 0) continue;
     const filename = stripSpanSuffix(trimmed);
@@ -4554,7 +4734,7 @@ async function collectBrokenForMarker(captured, line, pageFile, sourcesDir, line
         severity: "error",
         file: pageFile,
         message: `Broken citation ^[${filename}] \u2014 source file not found`,
-        line
+        line: line2
       });
       continue;
     }
@@ -4567,7 +4747,7 @@ async function collectBrokenForMarker(captured, line, pageFile, sourcesDir, line
       severity: "error",
       file: pageFile,
       message: `Claim-level span ^[${trimmed}] is out of bounds (source has only ${lineCount} lines)`,
-      line
+      line: line2
     });
   }
 }
@@ -4589,15 +4769,15 @@ async function checkMalformedClaimCitations(root) {
 }
 function checkPageMalformedCitations(content, filePath) {
   const results = [];
-  for (const { captured, line } of findMatchesInContent(content, CITATION_PATTERN)) {
-    for (const part of captured.split(",")) {
+  for (const { captured, line: line2 } of findMatchesInContent(content, CITATION_PATTERN)) {
+    for (const part of splitCitationMarker(captured)) {
       if (!isMalformedCitationEntry(part)) continue;
       results.push({
         rule: "malformed-claim-citation",
         severity: "error",
         file: filePath,
         message: `Malformed claim citation ^[${captured}] \u2014 expected file.md, file.md:N-N, or file.md#LN-LN`,
-        line
+        line: line2
       });
     }
   }
@@ -5207,8 +5387,8 @@ function collapseToPages(chunks, limit) {
   return slugs;
 }
 function buildChunkReasoning(chunks, pages) {
-  const top = chunks.slice(0, pages.length);
-  const summary = top.map((c) => `${c.slug}#${c.chunkIndex} (${c.score.toFixed(3)})`).join(", ");
+  const top2 = chunks.slice(0, pages.length);
+  const summary = top2.map((c) => `${c.slug}#${c.chunkIndex} (${c.score.toFixed(3)})`).join(", ");
   return `Selected ${pages.length} page(s) from ${chunks.length} reranked chunks: ${summary}`;
 }
 function buildDebug(chunks, pageSlugs, reranked) {
@@ -5420,18 +5600,21 @@ async function watchCommand() {
   let compiling = false;
   let pendingRecompile = false;
   let debounceTimer = null;
-  const triggerCompile = async () => {
-    if (compiling) {
-      pendingRecompile = true;
-      return;
-    }
-    compiling = true;
+  const runCompileOnce = async () => {
     try {
       await compile(process.cwd());
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       status("!", error(`Compile failed: ${msg}`));
     }
+  };
+  const triggerCompile = async () => {
+    if (compiling) {
+      pendingRecompile = true;
+      return;
+    }
+    compiling = true;
+    await runCompileOnce();
     compiling = false;
     if (pendingRecompile) {
       pendingRecompile = false;
@@ -5526,140 +5709,895 @@ async function lintCommand() {
   }
 }
 
-// src/commands/export.ts
+// src/eval/health.ts
+var MAX_SCORE = 100;
+var ERROR_DEDUCTION = 4;
+var CONTRADICTED_DEDUCTION = 2;
+var DEFAULT_DEDUCTION = 1;
+var ERROR_RULES = /* @__PURE__ */ new Set([
+  "broken-wikilink",
+  "broken-citation",
+  "duplicate-concept"
+]);
+function deductionFor(result) {
+  if (ERROR_RULES.has(result.rule)) return ERROR_DEDUCTION;
+  if (result.rule === "contradicted-page") return CONTRADICTED_DEDUCTION;
+  return DEFAULT_DEDUCTION;
+}
+function aggregateRules(results) {
+  const map = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const existing = map.get(result.rule);
+    const deduction = deductionFor(result);
+    if (existing) {
+      existing.count++;
+      existing.deduction += deduction;
+    } else {
+      map.set(result.rule, {
+        rule: result.rule,
+        count: 1,
+        severity: result.severity,
+        deduction
+      });
+    }
+  }
+  return Array.from(map.values());
+}
+async function evaluateHealth(root) {
+  const schema = await loadSchema(root);
+  const allResults = (await Promise.all([
+    checkBrokenWikilinks(root),
+    checkBrokenCitations(root),
+    checkMalformedClaimCitations(root),
+    checkOrphanedPages(root),
+    checkMissingSummaries(root),
+    checkDuplicateConcepts(root),
+    checkEmptyPages(root),
+    checkLowConfidencePages(root),
+    checkContradictedPages(root),
+    checkInferredWithoutCitations(root),
+    checkSchemaCrossLinks(root, schema)
+  ])).flat();
+  const rules = aggregateRules(allResults);
+  const totalDeduction = rules.reduce((sum, r) => sum + r.deduction, 0);
+  const score = Math.max(0, MAX_SCORE - totalDeduction);
+  return { score, maxScore: MAX_SCORE, rules };
+}
+
+// src/eval/citation-coverage.ts
+import path37 from "path";
+
+// src/eval/source-path.ts
+import { realpath as realpath4 } from "fs/promises";
 import path36 from "path";
-import { createRequire } from "module";
+function containsParentSegment(file) {
+  return file.split(/[/\\]/).some((seg) => seg === "..");
+}
+function isInside(parent, candidate) {
+  if (candidate === parent) return true;
+  const parentWithSep = parent.endsWith(path36.sep) ? parent : parent + path36.sep;
+  return candidate.startsWith(parentWithSep);
+}
+async function resolveSourceFile(sourcesDir, file) {
+  if (file.length === 0 || path36.isAbsolute(file)) return null;
+  if (containsParentSegment(file)) return null;
+  const joined = path36.join(sourcesDir, file);
+  if (!isInside(sourcesDir, path36.resolve(joined))) return null;
+  try {
+    const realDir = await realpath4(sourcesDir);
+    const realFile = await realpath4(joined);
+    if (!isInside(realDir, realFile)) return null;
+    return realFile;
+  } catch {
+    return null;
+  }
+}
 
-// src/export/collect.ts
-function toExportPage(raw) {
-  const meta = raw.frontmatter;
+// src/eval/citation-coverage.ts
+var PROSE_LEAD_RE = new RegExp("^\\p{L}", "u");
+async function evaluatePage(slug, body, sourcesDir) {
+  const paragraphs = body.split(/\n\s*\n/).filter((p) => PROSE_LEAD_RE.test(p.trim()));
+  let citedParagraphs = 0;
+  let totalCitations = 0;
+  let validCitations = 0;
+  for (const para of paragraphs) {
+    const citations = extractClaimCitations(para);
+    if (citations.length === 0) continue;
+    citedParagraphs++;
+    for (const { spans } of citations) {
+      for (const span of spans) {
+        totalCitations++;
+        if (await resolveSourceFile(sourcesDir, span.file) !== null) validCitations++;
+      }
+    }
+  }
   return {
-    title: raw.title,
-    slug: raw.slug,
-    pageDirectory: raw.pageDirectory,
-    summary: typeof meta.summary === "string" ? meta.summary : "",
-    sources: Array.isArray(meta.sources) ? meta.sources.filter((s) => typeof s === "string") : [],
-    tags: Array.isArray(meta.tags) ? meta.tags.filter((t) => typeof t === "string") : [],
-    createdAt: typeof meta.createdAt === "string" ? meta.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
-    updatedAt: typeof meta.updatedAt === "string" ? meta.updatedAt : (/* @__PURE__ */ new Date()).toISOString(),
-    links: extractWikilinkSlugs(raw.body),
-    body: raw.body
+    pageResult: { slug, proseParagraphs: paragraphs.length, citedParagraphs },
+    proseParagraphs: paragraphs.length,
+    citedParagraphs,
+    totalCitations,
+    validCitations
   };
 }
-async function collectExportPages(root) {
-  const raw = await collectRawWikiPages(root);
-  const kept = raw.filter((page) => page.parseStatus.hasTitle && !page.parseStatus.orphaned);
-  const pages = kept.map(toExportPage);
-  pages.sort((a, b) => a.title.localeCompare(b.title));
-  return pages;
+async function evaluateCitationCoverage(root) {
+  const pages = await collectAllPages(root);
+  const sourcesDir = path37.join(root, SOURCES_DIR);
+  let totalProse = 0;
+  let totalCited = 0;
+  let totalCitations = 0;
+  let totalValid = 0;
+  const perPage = [];
+  for (const { filePath, content } of pages) {
+    const { body } = parseFrontmatter(content);
+    const slug = path37.basename(filePath, ".md");
+    const stats = await evaluatePage(slug, body, sourcesDir);
+    totalProse += stats.proseParagraphs;
+    totalCited += stats.citedParagraphs;
+    totalCitations += stats.totalCitations;
+    totalValid += stats.validCitations;
+    perPage.push(stats.pageResult);
+  }
+  const coveragePercent = totalProse === 0 ? 0 : totalCited / totalProse * 100;
+  const precisionPercent = totalCitations === 0 ? 0 : totalValid / totalCitations * 100;
+  return {
+    totalProseParagraphs: totalProse,
+    citedParagraphs: totalCited,
+    coveragePercent,
+    totalCitations,
+    validCitations: totalValid,
+    precisionPercent,
+    perPage
+  };
 }
 
-// src/export/llms-txt.ts
-function pageRelativePath(page) {
-  return `wiki/${page.pageDirectory}/${page.slug}.md`;
-}
-function buildEntryNote(page) {
-  const parts = [];
-  if (page.summary) parts.push(page.summary);
-  if (page.tags.length > 0) parts.push(`tags: ${page.tags.join(", ")}`);
-  if (page.sources.length > 0) parts.push(`sources: ${page.sources.join(", ")}`);
-  parts.push(`created: ${page.createdAt}`);
-  parts.push(`updated: ${page.updatedAt}`);
-  return parts.join(" | ");
+// src/eval/citation-support.ts
+import { createHash as createHash4 } from "crypto";
+import { readFile as readFile24, appendFile, mkdir as mkdir7 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import path38 from "path";
+var CACHE_DIR = path38.join(".llmwiki", "eval");
+var CACHE_FILE = path38.join(CACHE_DIR, "citation-cache.jsonl");
+var PROSE_LEAD_RE2 = new RegExp("^\\p{L}", "u");
+var JUDGE_TOOL = {
+  name: "judge_citation",
+  description: "Rate how well the source excerpt supports the claim.",
+  input_schema: {
+    type: "object",
+    properties: {
+      score: {
+        type: "integer",
+        enum: [0, 1, 2],
+        description: "0=not supported or contradicted, 1=partially supported, 2=fully supported"
+      },
+      reason: { type: "string", description: "One sentence explaining the rating." }
+    },
+    required: ["score", "reason"]
+  }
+};
+var JUDGE_SYSTEM = "You are an expert fact-checker. Given a claim from a wiki article and a source excerpt, rate whether the source supports the claim. Be strict: partial credit only if the source addresses the claim but is incomplete. Important: if the source excerpt consists entirely of YAML frontmatter (metadata fields such as title, date, author, or tags between --- delimiters), treat it as non-evidence for any substantive claim and score it 0, unless the claim is explicitly about that metadata field.";
+var JUDGE_CONFIG_HASH = createHash4("sha256").update(JUDGE_SYSTEM + JSON.stringify(JUDGE_TOOL)).digest("hex").slice(0, 8);
+function hashPair(claimText, spanText) {
+  return createHash4("sha256").update(claimText + spanText).digest("hex").slice(0, 16);
+}
+function makeCacheKey(contentHash, model) {
+  return createHash4("sha256").update(contentHash + JUDGE_CONFIG_HASH + model).digest("hex").slice(0, 16);
+}
+async function readSourceLines(filePath, start, end) {
+  const content = await readFile24(filePath, "utf-8");
+  return content.split("\n").slice(start - 1, end).join("\n");
+}
+function stripCitationMarkers(paragraph) {
+  return paragraph.replace(/\^\[[^\]]+\]/g, "").trim();
+}
+async function buildSpanPair(slug, claimText, span, sourcesDir) {
+  if (!span.lines) return null;
+  const sourceFile = await resolveSourceFile(sourcesDir, span.file);
+  if (sourceFile === null) return null;
+  const spanText = await readSourceLines(sourceFile, span.lines.start, span.lines.end);
+  return {
+    claimHash: hashPair(claimText, spanText),
+    pageSlug: slug,
+    claimText,
+    citedFile: span.file,
+    spanText,
+    lineStart: span.lines.start,
+    lineEnd: span.lines.end
+  };
 }
-function formatPageEntry(page) {
-  const note = buildEntryNote(page);
-  return `- [${page.title}](${pageRelativePath(page)}): ${note}`;
+async function extractParagraphPairs(slug, para, sourcesDir) {
+  const citations = extractClaimCitations(para);
+  if (citations.length === 0) return [];
+  const claimText = stripCitationMarkers(para);
+  const spans = citations.flatMap((c) => c.spans);
+  const pairs = await Promise.all(spans.map((s) => buildSpanPair(slug, claimText, s, sourcesDir)));
+  return pairs.filter((p) => p !== null);
 }
-function buildSection(heading, pages) {
-  if (pages.length === 0) return [];
-  return [`## ${heading}`, "", ...pages.map(formatPageEntry), ""];
+async function extractPagePairs(slug, body, sourcesDir) {
+  const paragraphs = body.split(/\n\s*\n/).filter((p) => PROSE_LEAD_RE2.test(p.trim()));
+  const results = await Promise.all(paragraphs.map((p) => extractParagraphPairs(slug, p, sourcesDir)));
+  return results.flat();
 }
-function buildLlmsTxt(pages, projectTitle) {
-  const concepts = pages.filter((p) => p.pageDirectory === "concepts");
-  const queries = pages.filter((p) => p.pageDirectory === "queries");
-  const lines = [
-    `# ${projectTitle}`,
-    "",
-    `> ${pages.length} pages \u2014 exported ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "",
-    ...buildSection("Concepts", concepts),
-    ...buildSection("Saved Queries", queries)
-  ];
-  return lines.join("\n");
+async function extractCitationPairs(root) {
+  const pages = await collectAllPages(root);
+  const sourcesDir = path38.join(root, SOURCES_DIR);
+  const all = [];
+  for (const { filePath, content } of pages) {
+    const { body } = parseFrontmatter(content);
+    const slug = path38.basename(filePath, ".md");
+    const pairs = await extractPagePairs(slug, body, sourcesDir);
+    all.push(...pairs);
+  }
+  return all;
 }
-function buildLlmsFullTxt(pages, projectTitle) {
-  const sections = [buildLlmsTxt(pages, projectTitle)];
-  for (const page of pages) {
-    const tags = page.tags.length > 0 ? `
-Tags: ${page.tags.join(", ")}` : "";
-    const sources = page.sources.length > 0 ? `
-Sources: ${page.sources.join(", ")}` : "";
-    const header2 = [
-      "---",
-      `## ${page.title}`,
-      `> ${page.summary}${tags}${sources}`,
-      `Created: ${page.createdAt} | Updated: ${page.updatedAt}`,
-      ""
-    ].join("\n");
-    sections.push(`${header2}
-${page.body.trim()}
-`);
+function selectDeterministicSample(pairs, sampleSize, previousHashes = []) {
+  const pairByHash = new Map(pairs.map((p) => [p.claimHash, p]));
+  const retained = previousHashes.flatMap((h) => {
+    const p = pairByHash.get(h);
+    return p ? [p] : [];
+  });
+  if (retained.length >= sampleSize) return retained.slice(0, sampleSize);
+  const retainedSet = new Set(previousHashes);
+  const newPairs = pairs.filter((p) => !retainedSet.has(p.claimHash)).sort((a, b) => a.claimHash.localeCompare(b.claimHash));
+  return [...retained, ...newPairs].slice(0, sampleSize);
+}
+async function loadCachedJudgements(root) {
+  const cachePath = path38.join(root, CACHE_FILE);
+  if (!existsSync10(cachePath)) return /* @__PURE__ */ new Map();
+  const content = await readFile24(cachePath, "utf-8");
+  const map = /* @__PURE__ */ new Map();
+  for (const line2 of content.trim().split("\n").filter(Boolean)) {
+    try {
+      const entry = JSON.parse(line2);
+      map.set(entry.claimHash, entry);
+    } catch {
+    }
   }
-  return sections.join("\n");
+  return map;
 }
-
-// src/export/json-export.ts
-function buildJsonExport(pages) {
-  const doc = {
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    pageCount: pages.length,
-    pages
-  };
-  return JSON.stringify(doc, null, 2);
+async function appendCachedJudgement(root, judgement) {
+  await mkdir7(path38.join(root, CACHE_DIR), { recursive: true });
+  await appendFile(path38.join(root, CACHE_FILE), JSON.stringify(judgement) + "\n");
 }
-
-// src/export/json-ld.ts
-var LOCAL_BASE = "urn:llmwiki:";
-function pageIri(slug) {
-  return `${LOCAL_BASE}${slug}`;
+function resolveModel() {
+  const provider = process.env.LLMWIKI_PROVIDER ?? DEFAULT_PROVIDER;
+  return process.env.LLMWIKI_MODEL ?? PROVIDER_MODELS[provider] ?? provider;
 }
-function pageToJsonLd(page) {
-  const node = {
-    "@id": pageIri(page.slug),
-    "@type": "Article",
-    name: page.title,
-    description: page.summary,
-    dateCreated: page.createdAt,
-    dateModified: page.updatedAt
+async function callJudge(pair, cacheKey, model) {
+  const userMessage = `Claim: ${pair.claimText}
+
+Source (${pair.citedFile}, lines ${pair.lineStart}\u2013${pair.lineEnd}):
+${pair.spanText}`;
+  const raw = await callClaude({
+    system: JUDGE_SYSTEM,
+    messages: [{ role: "user", content: userMessage }],
+    tools: [JUDGE_TOOL],
+    maxTokens: 256
+  });
+  const parsed = JSON.parse(raw);
+  return {
+    claimHash: cacheKey,
+    pageSlug: pair.pageSlug,
+    citedFile: pair.citedFile,
+    lineStart: pair.lineStart,
+    lineEnd: pair.lineEnd,
+    claimText: pair.claimText,
+    spanText: pair.spanText,
+    score: parsed.score,
+    reason: parsed.reason,
+    model,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (page.tags.length > 0) {
-    node["keywords"] = page.tags;
-  }
-  if (page.sources.length > 0) {
-    node["isBasedOn"] = page.sources;
+}
+function aggregateJudgements(judgements) {
+  const fullySupported = judgements.filter((j) => j.score === 2).length;
+  const partiallySupported = judgements.filter((j) => j.score === 1).length;
+  const unsupported = judgements.filter((j) => j.score === 0).length;
+  const meanScore = judgements.length === 0 ? 0 : judgements.reduce((sum, j) => sum + j.score, 0) / judgements.length;
+  return { meanScore, fullySupported, partiallySupported, unsupported };
+}
+async function judgeNewPairs(sample, cache, root) {
+  const model = resolveModel();
+  const judgements = [];
+  let judgeErrors = 0;
+  let newPairsAttempted = 0;
+  let firstError;
+  for (const pair of sample) {
+    const cacheKey = makeCacheKey(pair.claimHash, model);
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      judgements.push(cached);
+    } else {
+      newPairsAttempted++;
+      try {
+        const judgement = await callJudge(pair, cacheKey, model);
+        await appendCachedJudgement(root, judgement);
+        judgements.push(judgement);
+      } catch (err) {
+        judgeErrors++;
+        if (firstError === void 0) firstError = err;
+      }
+    }
   }
-  if (page.links.length > 0) {
-    node["mentions"] = page.links.map((slug) => ({ "@id": pageIri(slug) }));
+  if (newPairsAttempted > 0 && judgeErrors === newPairsAttempted) {
+    const msg = firstError instanceof Error ? firstError.message : String(firstError);
+    throw new Error(`Citation judge failed for all ${judgeErrors} sampled pair(s): ${msg}`);
   }
-  return node;
+  return { judgements, judgeErrors };
 }
-function buildJsonLd(pages) {
-  const doc = {
-    "@context": "https://schema.org",
-    "@graph": pages.map(pageToJsonLd)
+async function evaluateCitationSupport(root, sampleSize = 20, previousHashes = []) {
+  const allPairs = await extractCitationPairs(root);
+  if (allPairs.length === 0) return null;
+  const sample = selectDeterministicSample(allPairs, sampleSize, previousHashes);
+  const cache = await loadCachedJudgements(root);
+  const { judgements, judgeErrors } = await judgeNewPairs(sample, cache, root);
+  return {
+    sampledCount: judgements.length,
+    sampledHashes: sample.map((p) => p.claimHash),
+    totalCitations: allPairs.length,
+    judgeErrors,
+    ...aggregateJudgements(judgements),
+    judgements
   };
-  return JSON.stringify(doc, null, 2);
 }
 
-// src/export/graphml.ts
-var XML_ESCAPES = {
-  "&": "&amp;",
-  "<": "&lt;",
-  ">": "&gt;",
-  '"': "&quot;",
-  "'": "&apos;"
-};
+// src/eval/stats.ts
+import { readdir as readdir12, appendFile as appendFile2, mkdir as mkdir8, readFile as readFile25 } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+import path39 from "path";
+var HISTORY_DIR = path39.join(".llmwiki", "eval");
+var HISTORY_FILE = path39.join(HISTORY_DIR, "history.jsonl");
+async function countFiles(dir) {
+  if (!existsSync11(dir)) return 0;
+  const entries = await readdir12(dir);
+  return entries.filter((e) => e.endsWith(".md")).length;
+}
+async function collectStats(root) {
+  const [sourceCount, pages, embeddingStore] = await Promise.all([
+    countFiles(path39.join(root, SOURCES_DIR)),
+    collectAllPages(root),
+    readEmbeddingStore(root)
+  ]);
+  let totalWikiChars = 0;
+  for (const { content } of pages) {
+    const { body } = parseFrontmatter(content);
+    totalWikiChars += body.length;
+  }
+  const pageCount = pages.length;
+  const avgPageLengthChars = pageCount === 0 ? 0 : Math.round(totalWikiChars / pageCount);
+  const embeddingCount = embeddingStore?.entries.length ?? 0;
+  const chunkEmbeddingCount = embeddingStore?.chunks?.length ?? 0;
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceCount,
+    pageCount,
+    totalWikiChars,
+    embeddingCount,
+    chunkEmbeddingCount,
+    avgPageLengthChars
+  };
+}
+async function appendHistory(root, report) {
+  const historyDir = path39.join(root, HISTORY_DIR);
+  await mkdir8(historyDir, { recursive: true });
+  await appendFile2(path39.join(root, HISTORY_FILE), JSON.stringify(report) + "\n");
+}
+async function loadHistory(root, n = 10) {
+  const historyPath = path39.join(root, HISTORY_FILE);
+  if (!existsSync11(historyPath)) return [];
+  const content = await readFile25(historyPath, "utf-8");
+  const lines = content.trim().split("\n").filter(Boolean);
+  const reports = [];
+  for (const line2 of lines.slice(-n)) {
+    try {
+      reports.push(JSON.parse(line2));
+    } catch {
+    }
+  }
+  return reports;
+}
+async function loadPreviousReport(root) {
+  const historyPath = path39.join(root, HISTORY_FILE);
+  if (!existsSync11(historyPath)) return null;
+  const content = await readFile25(historyPath, "utf-8");
+  const lines = content.trim().split("\n").filter(Boolean);
+  if (lines.length === 0) return null;
+  try {
+    return JSON.parse(lines[lines.length - 1]);
+  } catch {
+    return null;
+  }
+}
+
+// src/eval/delta.ts
+function computeDelta(current, previous) {
+  const delta = {
+    healthScore: current.health.score - previous.health.score,
+    citationCoveragePercent: current.citationCoverage.coveragePercent - previous.citationCoverage.coveragePercent,
+    citationPrecisionPercent: current.citationCoverage.precisionPercent - previous.citationCoverage.precisionPercent
+  };
+  if (current.citationSupport !== void 0 && previous.citationSupport !== void 0) {
+    delta.citationSupportMean = current.citationSupport.meanScore - previous.citationSupport.meanScore;
+  }
+  return delta;
+}
+
+// src/eval/thresholds.ts
+import { readFile as readFile26 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import path40 from "path";
+import yaml4 from "js-yaml";
+var THRESHOLDS_FILE = path40.join(".llmwiki", "eval", "thresholds.yaml");
+async function loadThresholds(root) {
+  const configPath = path40.join(root, THRESHOLDS_FILE);
+  if (!existsSync12(configPath)) return {};
+  const raw = await readFile26(configPath, "utf-8");
+  return yaml4.load(raw) ?? {};
+}
+async function checkThresholds(report, root) {
+  const config = await loadThresholds(root);
+  const violations = [];
+  if (config.health_score !== void 0 && report.health.score < config.health_score) {
+    violations.push(
+      `health_score ${report.health.score} is below threshold ${config.health_score}`
+    );
+  }
+  if (config.citation_coverage_percent !== void 0 && report.citationCoverage.coveragePercent < config.citation_coverage_percent) {
+    violations.push(
+      `citation_coverage_percent ${report.citationCoverage.coveragePercent.toFixed(1)}% is below threshold ${config.citation_coverage_percent}%`
+    );
+  }
+  if (config.citation_precision_percent !== void 0 && report.citationCoverage.precisionPercent < config.citation_precision_percent) {
+    violations.push(
+      `citation_precision_percent ${report.citationCoverage.precisionPercent.toFixed(1)}% is below threshold ${config.citation_precision_percent}%`
+    );
+  }
+  if (config.citation_support_mean !== void 0 && report.citationSupport !== void 0 && report.citationSupport.meanScore < config.citation_support_mean) {
+    violations.push(
+      `citation_support_mean ${report.citationSupport.meanScore.toFixed(2)} is below threshold ${config.citation_support_mean}`
+    );
+  }
+  if (config.citation_judge_error_max !== void 0 && report.citationSupport !== void 0 && report.citationSupport.judgeErrors > config.citation_judge_error_max) {
+    violations.push(
+      `citation_judge_errors ${report.citationSupport.judgeErrors} exceeds max ${config.citation_judge_error_max}`
+    );
+  }
+  return violations;
+}
+
+// src/eval/report.ts
+var BOX_WIDTH = 49;
+var HORIZONTAL = "\u2500".repeat(BOX_WIDTH);
+function line(content = "") {
+  return `\u2502 ${content.padEnd(BOX_WIDTH - 2)} \u2502`;
+}
+function top() {
+  return `\u250C${HORIZONTAL}\u2510`;
+}
+function divider() {
+  return `\u251C${HORIZONTAL}\u2524`;
+}
+function bottom() {
+  return `\u2514${HORIZONTAL}\u2518`;
+}
+function fmtDelta(value) {
+  if (value === void 0 || value === 0) return "";
+  const abs = Math.abs(value).toFixed(1).replace(/\.0$/, "");
+  return value > 0 ? dim(` (\u2191${abs})`) : dim(` (\u2193${abs})`);
+}
+function ruleRow(rule) {
+  if (rule.count === 0) return "";
+  const label = `    ${rule.rule}:`;
+  const right = `${rule.count}  (\u2212${rule.deduction})`;
+  const gap = BOX_WIDTH - 4 - label.length - right.length;
+  return line(`${label}${" ".repeat(Math.max(1, gap))}${right}`);
+}
+function formatHealth(report, delta) {
+  const scoreDelta = fmtDelta(delta?.healthScore);
+  const rows = [
+    line(),
+    line(bold(`Structural Health:  ${report.health.score} / 100${scoreDelta}`))
+  ];
+  for (const rule of report.health.rules) {
+    const row = ruleRow(rule);
+    if (row) rows.push(row);
+  }
+  return rows;
+}
+function formatCoverage(report, delta) {
+  const cov = report.citationCoverage;
+  const covDelta = fmtDelta(delta?.citationCoveragePercent);
+  const precDelta = fmtDelta(delta?.citationPrecisionPercent);
+  return [
+    line(),
+    line(bold(`Citation Coverage:  ${cov.coveragePercent.toFixed(0)}%${covDelta}`)),
+    line(`  ${cov.citedParagraphs} / ${cov.totalProseParagraphs} prose paragraphs cited`),
+    line(
+      `  Precision: ${cov.precisionPercent.toFixed(0)}%${precDelta} (${cov.validCitations}/${cov.totalCitations} valid)`
+    )
+  ];
+}
+function formatSupport(report, delta) {
+  const s = report.citationSupport;
+  if (!s) return [];
+  const meanDelta = fmtDelta(delta?.citationSupportMean);
+  const pctOf = (n) => s.sampledCount === 0 ? "\u2014" : `${(n / s.sampledCount * 100).toFixed(0)}%`;
+  const rows = [
+    line(),
+    line(bold(`Citation Support (${s.sampledCount} sampled):`)),
+    line(`  Mean score: ${s.meanScore.toFixed(2)} / 2.0${meanDelta}`),
+    line(`  Fully supported:     ${s.fullySupported}  (${pctOf(s.fullySupported)})`),
+    line(`  Partially supported: ${s.partiallySupported}  (${pctOf(s.partiallySupported)})`),
+    line(`  Unsupported:         ${s.unsupported}  (${pctOf(s.unsupported)})`)
+  ];
+  if (s.judgeErrors > 0) {
+    rows.push(line(error(`  Judge errors:        ${s.judgeErrors}`)));
+  }
+  return rows;
+}
+function formatStats(report) {
+  const s = report.stats;
+  return [
+    line(),
+    line(bold("Scale:")),
+    line(
+      `  Sources: ${s.sourceCount}  Pages: ${s.pageCount}  Chunks: ${s.chunkEmbeddingCount}`
+    ),
+    line(`  Wiki size: ${s.totalWikiChars.toLocaleString()} chars`)
+  ];
+}
+function formatViolations(violations) {
+  if (violations.length === 0) return [];
+  return [line(), ...violations.map((v) => line(error(`[FAIL] ${v}`)))];
+}
+function formatTerminalReport(report) {
+  const delta = report.delta;
+  const rows = [
+    top(),
+    line(bold("llmwiki eval \u2014 Wiki Quality Report")),
+    divider(),
+    ...formatHealth(report, delta),
+    ...formatCoverage(report, delta),
+    ...formatSupport(report, delta),
+    ...formatStats(report),
+    ...formatViolations(report.thresholdViolations),
+    line(),
+    bottom()
+  ];
+  return rows.join("\n");
+}
+function formatJsonReport(report) {
+  return JSON.stringify(report, null, 2);
+}
+function fmtTimestamp(iso) {
+  return iso.slice(0, 16).replace("T", " ");
+}
+function formatHistoryTable(reports) {
+  if (reports.length === 0) return "No eval history found. Run `llmwiki eval` to record the first run.";
+  const header2 = `${"Date".padEnd(18)}${"Suite".padEnd(7)}${"Health".padEnd(8)}${"Coverage".padEnd(10)}Support`;
+  const divider2 = "\u2500".repeat(header2.length);
+  const rows = reports.map((r) => {
+    const support = r.citationSupport ? r.citationSupport.meanScore.toFixed(2) : "\u2014";
+    return [
+      fmtTimestamp(r.timestamp).padEnd(18),
+      r.suite.padEnd(7),
+      String(r.health.score).padEnd(8),
+      `${r.citationCoverage.coveragePercent.toFixed(0)}%`.padEnd(10),
+      support
+    ].join("");
+  });
+  return [`Eval History  (${reports.length} run${reports.length === 1 ? "" : "s"})`, divider2, header2, divider2, ...rows].join("\n");
+}
+var SCORE_LABELS = {
+  2: "fully supported",
+  1: "partially supported",
+  0: "unsupported"
+};
+function pct(n, total) {
+  return total === 0 ? "0%" : `${(n / total * 100).toFixed(0)}%`;
+}
+function formatCacheShow(judgements, summary) {
+  const lines = [bold(`Citation Cache  \xB7  ${summary.total} judgements`)];
+  if (summary.total === 0) return lines.join("\n");
+  lines.push("");
+  lines.push(`  Score 2 (fully supported):     ${summary.fullySupported}  (${pct(summary.fullySupported, summary.total)})`);
+  lines.push(`  Score 1 (partially supported): ${summary.partiallySupported}  (${pct(summary.partiallySupported, summary.total)})`);
+  lines.push(`  Score 0 (unsupported):         ${summary.unsupported}  (${pct(summary.unsupported, summary.total)})`);
+  if (summary.byPage.length > 0) {
+    lines.push("");
+    lines.push("  Top pages:");
+    for (const { slug, count } of summary.byPage.slice(0, 10)) {
+      lines.push(`    ${slug}:  ${count} judgement${count === 1 ? "" : "s"}`);
+    }
+  }
+  void judgements;
+  return lines.join("\n");
+}
+var JUDGEMENT_DIVIDER = "\u2500".repeat(55);
+function formatJudgementsDisplay(judgements) {
+  if (judgements.length === 0) return "No judgements to display.";
+  const blocks = judgements.map((j, i) => {
+    const scoreLabel = SCORE_LABELS[j.score] ?? "unknown";
+    const header2 = `[${i + 1}/${judgements.length}] Page: ${j.pageSlug}  Score: ${j.score} (${scoreLabel})`;
+    return [
+      JUDGEMENT_DIVIDER,
+      header2,
+      `  File: ${j.citedFile}  Lines: ${j.lineStart}\u2013${j.lineEnd}`,
+      `  Claim: "${j.claimText}"`,
+      `  Span:  "${j.spanText}"`,
+      `  Reason: ${j.reason}`
+    ].join("\n");
+  });
+  return [...blocks, JUDGEMENT_DIVIDER].join("\n");
+}
+
+// src/eval/cache.ts
+import { unlink as unlink3, readFile as readFile27 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import path41 from "path";
+var CACHE_FILE2 = path41.join(".llmwiki", "eval", "citation-cache.jsonl");
+async function clearCitationCache(root) {
+  const cachePath = path41.join(root, CACHE_FILE2);
+  if (!existsSync13(cachePath)) return false;
+  await unlink3(cachePath);
+  return true;
+}
+async function loadCitationCache(root) {
+  const cachePath = path41.join(root, CACHE_FILE2);
+  if (!existsSync13(cachePath)) return [];
+  const content = await readFile27(cachePath, "utf-8");
+  const judgements = [];
+  for (const line2 of content.trim().split("\n").filter(Boolean)) {
+    try {
+      judgements.push(JSON.parse(line2));
+    } catch {
+    }
+  }
+  return judgements;
+}
+function summarizeCitationCache(judgements) {
+  let fullySupported = 0;
+  let partiallySupported = 0;
+  let unsupported = 0;
+  const pageCounts = /* @__PURE__ */ new Map();
+  for (const j of judgements) {
+    if (j.score === 2) fullySupported++;
+    else if (j.score === 1) partiallySupported++;
+    else unsupported++;
+    pageCounts.set(j.pageSlug, (pageCounts.get(j.pageSlug) ?? 0) + 1);
+  }
+  const byPage = [...pageCounts.entries()].map(([slug, count]) => ({ slug, count })).sort((a, b) => b.count - a.count);
+  return { total: judgements.length, fullySupported, partiallySupported, unsupported, byPage };
+}
+
+// src/commands/eval.ts
+var DEFAULT_SAMPLE_SIZE = 20;
+function parseSampleSize(raw) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0) {
+    throw new Error(`--sample must be a positive integer (got "${raw}")`);
+  }
+  return n;
+}
+function resolveEvalOptions(options) {
+  return {
+    suite: options.suite === "full" ? "full" : "fast",
+    sampleSize: parseSampleSize(options.sample ?? String(DEFAULT_SAMPLE_SIZE)),
+    outFormat: options.out === "json" ? "json" : "terminal"
+  };
+}
+async function runEvalComponents(root, suite, sampleSize) {
+  const [health, citationCoverage, stats, previousReport] = await Promise.all([
+    evaluateHealth(root),
+    evaluateCitationCoverage(root),
+    collectStats(root),
+    loadPreviousReport(root)
+  ]);
+  const citationSupport = suite === "full" ? await evaluateCitationSupport(root, sampleSize, previousReport?.citationSupport?.sampledHashes ?? []) : void 0;
+  return { health, citationCoverage, stats, previousReport, citationSupport };
+}
+async function buildReport(root, components, suite) {
+  const { health, citationCoverage, stats, previousReport, citationSupport } = components;
+  const partial = {
+    suite,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    health,
+    citationCoverage,
+    stats,
+    ...citationSupport ? { citationSupport } : {}
+  };
+  const delta = previousReport ? computeDelta(partial, previousReport) : void 0;
+  const thresholdViolations = await checkThresholds(partial, root);
+  return { ...partial, ...delta ? { delta } : {}, thresholdViolations };
+}
+async function evalCommand(options = {}) {
+  const root = process.cwd();
+  const { suite, sampleSize, outFormat } = resolveEvalOptions(options);
+  const components = await runEvalComponents(root, suite, sampleSize);
+  const report = await buildReport(root, components, suite);
+  await appendHistory(root, report);
+  const output = outFormat === "json" ? formatJsonReport(report) : formatTerminalReport(report);
+  console.log(output);
+  if (report.thresholdViolations.length > 0) {
+    process.exit(1);
+  }
+}
+async function evalCacheClearCommand() {
+  const deleted = await clearCitationCache(process.cwd());
+  console.log(deleted ? "Citation cache cleared." : "No citation cache found.");
+}
+async function evalCacheShowCommand() {
+  const judgements = await loadCitationCache(process.cwd());
+  const summary = summarizeCitationCache(judgements);
+  console.log(formatCacheShow(judgements, summary));
+}
+async function evalReportCommand(options = {}) {
+  const report = await loadPreviousReport(process.cwd());
+  if (!report) {
+    console.log("No eval history found. Run `llmwiki eval` to record the first run.");
+    return;
+  }
+  const output = options.out === "json" ? formatJsonReport(report) : formatTerminalReport(report);
+  console.log(output);
+}
+async function evalHistoryCommand(options = {}) {
+  const n = parseInt(options.n ?? "10", 10);
+  const reports = await loadHistory(process.cwd(), n);
+  if (options.out === "json") {
+    console.log(JSON.stringify(reports, null, 2));
+    return;
+  }
+  console.log(formatHistoryTable(reports));
+}
+function filterJudgements(judgements, options) {
+  let result = judgements;
+  if (options.score !== void 0) result = result.filter((j) => j.score === parseInt(options.score, 10));
+  if (options.page) result = result.filter((j) => j.pageSlug === options.page);
+  if (options.n !== void 0) result = result.slice(0, parseInt(options.n, 10));
+  return result;
+}
+async function evalJudgementsCommand(options = {}) {
+  const judgements = filterJudgements(await loadCitationCache(process.cwd()), options);
+  if (options.out === "json") {
+    console.log(JSON.stringify(judgements, null, 2));
+    return;
+  }
+  console.log(formatJudgementsDisplay(judgements));
+}
+
+// src/commands/export.ts
+import path42 from "path";
+import { createRequire } from "module";
+
+// src/export/collect.ts
+function toExportPage(raw) {
+  const meta = raw.frontmatter;
+  return {
+    title: raw.title,
+    slug: raw.slug,
+    pageDirectory: raw.pageDirectory,
+    summary: typeof meta.summary === "string" ? meta.summary : "",
+    sources: Array.isArray(meta.sources) ? meta.sources.filter((s) => typeof s === "string") : [],
+    tags: Array.isArray(meta.tags) ? meta.tags.filter((t) => typeof t === "string") : [],
+    createdAt: typeof meta.createdAt === "string" ? meta.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: typeof meta.updatedAt === "string" ? meta.updatedAt : (/* @__PURE__ */ new Date()).toISOString(),
+    links: extractWikilinkSlugs(raw.body),
+    body: raw.body
+  };
+}
+async function collectExportPages(root) {
+  const raw = await collectRawWikiPages(root);
+  const kept = raw.filter((page) => page.parseStatus.hasTitle && !page.parseStatus.orphaned);
+  const pages = kept.map(toExportPage);
+  pages.sort((a, b) => a.title.localeCompare(b.title));
+  return pages;
+}
+
+// src/export/llms-txt.ts
+function pageRelativePath(page) {
+  return `wiki/${page.pageDirectory}/${page.slug}.md`;
+}
+function buildEntryNote(page) {
+  const parts = [];
+  if (page.summary) parts.push(page.summary);
+  if (page.tags.length > 0) parts.push(`tags: ${page.tags.join(", ")}`);
+  if (page.sources.length > 0) parts.push(`sources: ${page.sources.join(", ")}`);
+  parts.push(`created: ${page.createdAt}`);
+  parts.push(`updated: ${page.updatedAt}`);
+  return parts.join(" | ");
+}
+function formatPageEntry(page) {
+  const note = buildEntryNote(page);
+  return `- [${page.title}](${pageRelativePath(page)}): ${note}`;
+}
+function buildSection(heading, pages) {
+  if (pages.length === 0) return [];
+  return [`## ${heading}`, "", ...pages.map(formatPageEntry), ""];
+}
+function buildLlmsTxt(pages, projectTitle) {
+  const concepts = pages.filter((p) => p.pageDirectory === "concepts");
+  const queries = pages.filter((p) => p.pageDirectory === "queries");
+  const lines = [
+    `# ${projectTitle}`,
+    "",
+    `> ${pages.length} pages \u2014 exported ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    ...buildSection("Concepts", concepts),
+    ...buildSection("Saved Queries", queries)
+  ];
+  return lines.join("\n");
+}
+function buildLlmsFullTxt(pages, projectTitle) {
+  const sections = [buildLlmsTxt(pages, projectTitle)];
+  for (const page of pages) {
+    const tags = page.tags.length > 0 ? `
+Tags: ${page.tags.join(", ")}` : "";
+    const sources = page.sources.length > 0 ? `
+Sources: ${page.sources.join(", ")}` : "";
+    const header2 = [
+      "---",
+      `## ${page.title}`,
+      `> ${page.summary}${tags}${sources}`,
+      `Created: ${page.createdAt} | Updated: ${page.updatedAt}`,
+      ""
+    ].join("\n");
+    sections.push(`${header2}
+${page.body.trim()}
+`);
+  }
+  return sections.join("\n");
+}
+
+// src/export/json-export.ts
+function buildJsonExport(pages) {
+  const doc = {
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pageCount: pages.length,
+    pages
+  };
+  return JSON.stringify(doc, null, 2);
+}
+
+// src/export/json-ld.ts
+var LOCAL_BASE = "urn:llmwiki:";
+function pageIri(slug) {
+  return `${LOCAL_BASE}${slug}`;
+}
+function pageToJsonLd(page) {
+  const node = {
+    "@id": pageIri(page.slug),
+    "@type": "Article",
+    name: page.title,
+    description: page.summary,
+    dateCreated: page.createdAt,
+    dateModified: page.updatedAt
+  };
+  if (page.tags.length > 0) {
+    node["keywords"] = page.tags;
+  }
+  if (page.sources.length > 0) {
+    node["isBasedOn"] = page.sources;
+  }
+  if (page.links.length > 0) {
+    node["mentions"] = page.links.map((slug) => ({ "@id": pageIri(slug) }));
+  }
+  return node;
+}
+function buildJsonLd(pages) {
+  const doc = {
+    "@context": "https://schema.org",
+    "@graph": pages.map(pageToJsonLd)
+  };
+  return JSON.stringify(doc, null, 2);
+}
+
+// src/export/graphml.ts
+var XML_ESCAPES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&apos;"
+};
 function escapeXml(value) {
   return value.replace(/[&<>"']/g, (ch) => XML_ESCAPES[ch] ?? ch);
 }
@@ -5789,7 +6727,7 @@ var TARGET_FILENAMES = {
 };
 function resolveProjectTitle(root) {
   try {
-    const pkg = require2(path36.join(root, "package.json"));
+    const pkg = require2(path42.join(root, "package.json"));
     return typeof pkg.name === "string" ? pkg.name : "Knowledge Wiki";
   } catch {
     return "Knowledge Wiki";
@@ -5841,7 +6779,7 @@ async function runExport(root, options = {}) {
   const written = [];
   for (const target of targets) {
     const content = buildContent(target, pages, projectTitle, marpSource);
-    const outPath = path36.join(root, EXPORT_DIR, TARGET_FILENAMES[target]);
+    const outPath = path42.join(root, EXPORT_DIR, TARGET_FILENAMES[target]);
     await atomicWrite(outPath, content);
     written.push(outPath);
     status("+", success(`Exported ${target} \u2192 ${source(outPath)}`));
@@ -5867,18 +6805,18 @@ async function exportCommand(root, options) {
 }
 
 // src/commands/schema.ts
-import { existsSync as existsSync10 } from "fs";
-import { mkdir as mkdir7, writeFile as writeFile5 } from "fs/promises";
-import path37 from "path";
+import { existsSync as existsSync14 } from "fs";
+import { mkdir as mkdir9, writeFile as writeFile5 } from "fs/promises";
+import path43 from "path";
 async function schemaInitCommand() {
   const root = process.cwd();
   const defaults = buildDefaultSchema();
   const targetPath = defaultSchemaInitPath(root);
-  if (existsSync10(targetPath)) {
+  if (existsSync14(targetPath)) {
     status("!", warn(`Schema file already exists at ${targetPath}`));
     return;
   }
-  await mkdir7(path37.dirname(targetPath), { recursive: true });
+  await mkdir9(path43.dirname(targetPath), { recursive: true });
   const serializable = {
     version: defaults.version,
     defaultKind: defaults.defaultKind,
@@ -5914,121 +6852,1814 @@ async function reviewListCommand() {
     dim(`Use \`llmwiki review show <id>\` to inspect a candidate.`)
   );
 }
-
-// src/commands/review-show.ts
-async function reviewShowCommand(id) {
-  const candidate = await loadCandidateOrFail(process.cwd(), id);
-  if (!candidate) return;
-  header(`Candidate ${candidate.id}`);
-  status("i", dim(`title:      ${candidate.title}`));
-  status("i", dim(`slug:       ${candidate.slug}`));
-  status("i", dim(`summary:    ${candidate.summary}`));
-  status("i", dim(`sources:    ${candidate.sources.join(", ")}`));
-  status("i", dim(`generated:  ${candidate.generatedAt}`));
-  console.log();
-  console.log(candidate.body);
-  if (candidate.schemaViolations && candidate.schemaViolations.length > 0) {
-    console.log();
-    header("Schema violations");
-    for (const v of candidate.schemaViolations) {
-      status("!", warn(`[${v.severity}] ${v.message}`));
-    }
+
+// src/commands/review-show.ts
+async function reviewShowCommand(id) {
+  const candidate = await loadCandidateOrFail(process.cwd(), id);
+  if (!candidate) return;
+  header(`Candidate ${candidate.id}`);
+  status("i", dim(`title:      ${candidate.title}`));
+  status("i", dim(`slug:       ${candidate.slug}`));
+  status("i", dim(`summary:    ${candidate.summary}`));
+  status("i", dim(`sources:    ${candidate.sources.join(", ")}`));
+  status("i", dim(`generated:  ${candidate.generatedAt}`));
+  console.log();
+  console.log(candidate.body);
+  if (candidate.schemaViolations && candidate.schemaViolations.length > 0) {
+    console.log();
+    header("Schema violations");
+    for (const v of candidate.schemaViolations) {
+      status("!", warn(`[${v.severity}] ${v.message}`));
+    }
+  }
+  if (candidate.provenanceViolations && candidate.provenanceViolations.length > 0) {
+    console.log();
+    header("Provenance violations");
+    for (const v of candidate.provenanceViolations) {
+      status("!", warn(`[${v.severity}] ${v.message}`));
+    }
+  }
+}
+
+// src/commands/review-approve.ts
+import path44 from "path";
+
+// src/commands/review-helpers.ts
+async function runReviewUnderLock(id, underLock) {
+  const root = process.cwd();
+  const preCheck = await loadCandidateOrFail(root, id);
+  if (!preCheck) return;
+  const locked = await acquireLock(root);
+  if (!locked) {
+    status("!", error("Could not acquire lock. Try again later."));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    await underLock(root, id);
+  } finally {
+    await releaseLock(root);
+  }
+}
+
+// src/commands/review-approve.ts
+async function reviewApproveCommand(id) {
+  await runReviewUnderLock(id, approveUnderLock);
+}
+async function approveUnderLock(root, id) {
+  const candidate = await loadCandidateUnderLockOrFail(root, id);
+  if (!candidate) return;
+  if (!validateWikiPage(candidate.body)) {
+    status("!", error(`Candidate ${id} failed page validation; not approved.`));
+    process.exitCode = 1;
+    return;
+  }
+  const pagePath = path44.join(root, CONCEPTS_DIR, `${candidate.slug}.md`);
+  await atomicWrite(pagePath, candidate.body);
+  status("+", success(`Approved \u2192 ${source(pagePath)}`));
+  await persistCandidateSourceStates(root, candidate);
+  await refreshWikiAfterApproval(root, candidate.slug);
+  await deleteCandidate(root, id);
+  status("\u2713", dim(`Candidate ${id} cleared.`));
+}
+async function persistCandidateSourceStates(root, candidate) {
+  const states = candidate.sourceStates;
+  if (!states) return;
+  const otherSources = await collectOtherCandidateSources(root, candidate.id);
+  for (const [sourceFile, entry] of Object.entries(states)) {
+    if (otherSources.has(sourceFile)) continue;
+    await updateSourceState(root, sourceFile, entry);
+  }
+}
+async function collectOtherCandidateSources(root, approvingId) {
+  const pending = await listCandidates(root);
+  const sources = /* @__PURE__ */ new Set();
+  for (const candidate of pending) {
+    if (candidate.id === approvingId) continue;
+    for (const source2 of candidate.sources) sources.add(source2);
+  }
+  return sources;
+}
+async function refreshWikiAfterApproval(root, slug) {
+  await resolveLinks(root, [slug], [slug]);
+  await generateIndex(root);
+  await generateMOC(root);
+  await safelyUpdateEmbeddings2(root, [slug]);
+}
+async function safelyUpdateEmbeddings2(root, slugs) {
+  try {
+    await updateEmbeddings(root, slugs);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    status("!", warn(`Skipped embeddings update: ${message}`));
+  }
+}
+
+// src/commands/review-reject.ts
+async function reviewRejectCommand(id) {
+  await runReviewUnderLock(id, rejectUnderLock);
+}
+async function rejectUnderLock(root, id) {
+  const candidate = await loadCandidateUnderLockOrFail(root, id);
+  if (!candidate) return;
+  await archiveCandidate(root, id);
+  status(
+    "-",
+    warn(`Rejected candidate ${id} (${candidate.slug}) \u2014 archived, wiki unchanged.`)
+  );
+}
+
+// src/project/state.ts
+import { stat as stat2, readdir as readdir13, readFile as readFile28 } from "fs/promises";
+import path45 from "path";
+var MARKDOWN_EXT = ".md";
+async function collectProjectState(root) {
+  const rootReadable = await isDirectory(root);
+  if (!rootReadable) return brokenProjectState(root);
+  const dirs = await collectDirPresence(root);
+  const counts = await collectPageCounts(root, dirs);
+  const lint2 = await collectLintCacheStatus(root);
+  const mtimes = await collectMtimes(root, dirs);
+  return assembleState({ root, dirs, counts, lint: lint2, mtimes });
+}
+function brokenProjectState(root) {
+  return {
+    root,
+    hasSourcesDir: false,
+    hasWikiDir: false,
+    hasInternalDir: false,
+    sourceCount: 0,
+    conceptCount: 0,
+    queryCount: 0,
+    pendingCandidates: 0,
+    hasIndex: false,
+    lint: { present: false, entry: null },
+    latestWikiMtimeMs: null,
+    latestSourceMtimeMs: null,
+    warnings: [
+      {
+        code: "project-unreadable",
+        message: `Project root is unreadable or could not be inspected: ${root}`
+      }
+    ]
+  };
+}
+async function collectDirPresence(root) {
+  const [hasSourcesDir, hasWikiDir, hasInternalDir] = await Promise.all([
+    isDirectory(path45.join(root, SOURCES_DIR)),
+    isDirectory(path45.join(root, "wiki")),
+    isDirectory(path45.join(root, LLMWIKI_DIR))
+  ]);
+  return { hasSourcesDir, hasWikiDir, hasInternalDir };
+}
+async function collectPageCounts(root, dirs) {
+  const [sourceCount, conceptCount, queryCount, pendingCandidates, hasIndex] = await Promise.all([
+    dirs.hasSourcesDir ? countMarkdownFiles(path45.join(root, SOURCES_DIR)) : 0,
+    dirs.hasWikiDir ? countMarkdownFiles(path45.join(root, CONCEPTS_DIR)) : 0,
+    dirs.hasWikiDir ? countMarkdownFiles(path45.join(root, QUERIES_DIR)) : 0,
+    dirs.hasInternalDir ? safeCountCandidates(root) : 0,
+    dirs.hasWikiDir ? isFile(path45.join(root, INDEX_FILE)) : false
+  ]);
+  return { sourceCount, conceptCount, queryCount, pendingCandidates, hasIndex };
+}
+async function collectMtimes(root, dirs) {
+  const [latestWikiMtimeMs, latestSourceMtimeMs] = await Promise.all([
+    dirs.hasWikiDir ? safeMtime(path45.join(root, "wiki")) : Promise.resolve(null),
+    dirs.hasSourcesDir ? safeMtime(path45.join(root, SOURCES_DIR)) : Promise.resolve(null)
+  ]);
+  return { latestWikiMtimeMs, latestSourceMtimeMs };
+}
+async function collectLintCacheStatus(root) {
+  const cachePath = path45.join(root, LAST_LINT_FILE);
+  const exists = await isFile(cachePath);
+  if (!exists) return { present: false, entry: null };
+  const entry = await readLintCacheEntry(cachePath);
+  return { present: true, entry };
+}
+async function readLintCacheEntry(cachePath) {
+  let raw;
+  try {
+    raw = await readFile28(cachePath, "utf-8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return validateCacheShape(parsed);
+  } catch {
+    return null;
+  }
+}
+function validateCacheShape(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  const { warnings, errors, at } = candidate;
+  if (!isNonNegativeInteger2(warnings)) return null;
+  if (!isNonNegativeInteger2(errors)) return null;
+  if (typeof at !== "string" || !LINT_CACHE_TIMESTAMP_PATTERN.test(at)) return null;
+  return { warnings, errors, at };
+}
+function isNonNegativeInteger2(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function assembleState(input) {
+  const { root, dirs, counts, lint: lint2, mtimes } = input;
+  const warnings = buildWarnings({ dirs, counts, lint: lint2, mtimes });
+  return { root, ...dirs, ...counts, lint: lint2, ...mtimes, warnings };
+}
+function buildWarnings(input) {
+  const warnings = [];
+  appendLintWarnings(warnings, input.lint, input.mtimes.latestWikiMtimeMs);
+  appendStructuralWarnings(warnings, input.dirs, input.counts);
+  return warnings;
+}
+function appendLintWarnings(warnings, lint2, latestWikiMtimeMs) {
+  if (lint2.present && lint2.entry === null) {
+    warnings.push({
+      code: "lint-cache-unparseable",
+      message: "Lint cache file exists but could not be parsed. Re-run `llmwiki lint`."
+    });
+    return;
+  }
+  if (lint2.entry && isLintCacheStale(lint2.entry, latestWikiMtimeMs)) {
+    warnings.push({
+      code: "lint-cache-stale",
+      message: "Lint cache is older than the wiki directory; pages were added or removed since the last lint."
+    });
+  }
+}
+function appendStructuralWarnings(warnings, dirs, counts) {
+  const hasPages = counts.conceptCount > 0 || counts.queryCount > 0;
+  if (hasPages && !counts.hasIndex) {
+    warnings.push({
+      code: "index-missing",
+      message: "wiki/index.md is missing even though pages exist."
+    });
+  }
+  if (counts.pendingCandidates > 0) {
+    warnings.push({
+      code: "pending-candidates",
+      message: `${counts.pendingCandidates} generated candidate${counts.pendingCandidates === 1 ? "" : "s"} waiting for review.`
+    });
+  }
+  if (dirs.hasSourcesDir && counts.sourceCount > 0 && !hasPages) {
+    warnings.push({
+      code: "sources-not-compiled",
+      message: "Sources exist but no wiki pages were found. Run `llmwiki compile`."
+    });
+  }
+}
+function isLintCacheStale(entry, latestWikiMtimeMs) {
+  if (latestWikiMtimeMs === null) return false;
+  const lintMs = Date.parse(entry.at);
+  if (Number.isNaN(lintMs)) return false;
+  return latestWikiMtimeMs > lintMs;
+}
+async function isDirectory(target) {
+  try {
+    const stats = await stat2(target);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function isFile(target) {
+  try {
+    const stats = await stat2(target);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function safeMtime(target) {
+  try {
+    const stats = await stat2(target);
+    return stats.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+async function countMarkdownFiles(dir) {
+  try {
+    const entries = await readdir13(dir, { withFileTypes: true });
+    let count = 0;
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(MARKDOWN_EXT)) count += 1;
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+async function safeCountCandidates(root) {
+  try {
+    return await countCandidates(root);
+  } catch {
+    return 0;
+  }
+}
+
+// src/project/recommendations.ts
+function recommendNextAction(state) {
+  const kind = classifyState(state);
+  return { state: kind, recommended: primaryAction(kind), otherActions: otherActionsFor(kind) };
+}
+function classifyState(state) {
+  if (isBrokenProject(state)) return "broken-project";
+  if (isSourcesOnly(state)) return "sources-only";
+  if (state.pendingCandidates > 0) return "review-pending";
+  if (hasLintErrors(state)) return "lint-attention";
+  if (hasWikiPages(state)) return "wiki-ready";
+  if (isEmptyWiki(state)) return "empty-wiki";
+  return "fresh";
+}
+function isBrokenProject(state) {
+  return state.warnings.some((w) => w.code === "project-unreadable");
+}
+function isEmptyWiki(state) {
+  return state.hasWikiDir && !hasWikiPages(state);
+}
+function isSourcesOnly(state) {
+  return state.sourceCount > 0 && !hasWikiPages(state);
+}
+function hasLintErrors(state) {
+  return state.lint.entry !== null && state.lint.entry.errors > 0;
+}
+function hasWikiPages(state) {
+  return state.conceptCount > 0 || state.queryCount > 0;
+}
+function primaryAction(kind) {
+  return PRIMARY_ACTIONS[kind];
+}
+function otherActionsFor(kind) {
+  return OTHER_ACTIONS[kind].map((a) => ({ ...a }));
+}
+var QUICKSTART_ACTION = {
+  command: "llmwiki quickstart <source>",
+  reason: "Ingest a source and compile a wiki in one step.",
+  executable: { binary: "llmwiki", args: ["quickstart"], placeholders: ["source"] }
+};
+var INGEST_ACTION = {
+  command: "llmwiki ingest <source>",
+  reason: "Add sources manually before compiling.",
+  executable: { binary: "llmwiki", args: ["ingest"], placeholders: ["source"] }
+};
+var COMPILE_ACTION = {
+  command: "llmwiki compile",
+  reason: "Compile sources/ into wiki pages.",
+  executable: { binary: "llmwiki", args: ["compile"] }
+};
+var REVIEW_LIST_ACTION = {
+  command: "llmwiki review list",
+  reason: "List pending candidate pages.",
+  executable: { binary: "llmwiki", args: ["review", "list"] }
+};
+var REVIEW_APPROVE_ACTION = {
+  command: "llmwiki review approve <id>",
+  reason: "Approve a candidate after inspecting it with `llmwiki review show <id>`.",
+  executable: { binary: "llmwiki", args: ["review", "approve"], placeholders: ["id"] }
+};
+var LINT_ACTION = {
+  command: "llmwiki lint",
+  reason: "Re-run lint to inspect outstanding errors.",
+  executable: { binary: "llmwiki", args: ["lint"] }
+};
+var VIEW_OPEN_ACTION = {
+  command: "llmwiki view --open",
+  reason: "Browse the compiled wiki in the local viewer.",
+  executable: { binary: "llmwiki", args: ["view", "--open"] }
+};
+var QUERY_ACTION = {
+  command: 'llmwiki query "<question>"',
+  reason: "Ask a natural-language question against the compiled wiki.",
+  executable: { binary: "llmwiki", args: ["query"], placeholders: ["question"] }
+};
+var BROKEN_PROJECT_ACTION = {
+  command: null,
+  reason: "Project root is unreadable or could not be inspected.",
+  executable: null
+};
+var PRIMARY_ACTIONS = {
+  "broken-project": BROKEN_PROJECT_ACTION,
+  fresh: { ...QUICKSTART_ACTION, reason: "No sources or wiki pages were found." },
+  "sources-only": { ...COMPILE_ACTION, reason: "Sources exist but no wiki pages have been compiled." },
+  "review-pending": { ...REVIEW_LIST_ACTION, reason: "Generated candidates are waiting for review." },
+  "lint-attention": { ...LINT_ACTION, reason: "Lint has reported errors; rerun lint to inspect them." },
+  "wiki-ready": { ...VIEW_OPEN_ACTION, reason: "Wiki pages are ready to browse." },
+  "empty-wiki": {
+    ...COMPILE_ACTION,
+    reason: "wiki/ exists but is empty; run compile or add sources first."
+  }
+};
+var OTHER_ACTIONS = {
+  fresh: [INGEST_ACTION, QUICKSTART_ACTION],
+  "sources-only": [COMPILE_ACTION, QUICKSTART_ACTION],
+  "empty-wiki": [COMPILE_ACTION, INGEST_ACTION],
+  "review-pending": [REVIEW_LIST_ACTION, REVIEW_APPROVE_ACTION],
+  "lint-attention": [LINT_ACTION, VIEW_OPEN_ACTION],
+  "wiki-ready": [VIEW_OPEN_ACTION, QUERY_ACTION],
+  "broken-project": []
+};
+
+// src/commands/next.ts
+var NEXT_JSON_VERSION = 1;
+var STATE_LINE_RENDERERS = {
+  "broken-project": () => "project root unreadable",
+  fresh: () => "no llmwiki project detected",
+  "sources-only": (state) => `${state.sourceCount} source${plural(state.sourceCount)}, no wiki pages yet`,
+  "review-pending": (state) => `review pending, ${state.pendingCandidates} candidate${plural(state.pendingCandidates)}`,
+  "lint-attention": formatLintAttentionLine,
+  "empty-wiki": () => "wiki/ exists but is empty",
+  "wiki-ready": formatWikiReadyLine
+};
+async function nextCommand(options = {}) {
+  const state = await collectProjectState(process.cwd());
+  const recommendation = recommendNextAction(state);
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(buildJsonPayload(state, recommendation), null, 2)}
+`);
+  } else {
+    process.stdout.write(`${renderHuman(state, recommendation)}
+`);
+  }
+  return 0;
+}
+function buildJsonPayload(state, recommendation) {
+  return {
+    version: NEXT_JSON_VERSION,
+    projectRoot: state.root,
+    state: recommendation.state,
+    summary: buildSummary(state),
+    recommended: recommendation.recommended,
+    otherActions: recommendation.otherActions,
+    warnings: state.warnings
+  };
+}
+function buildSummary(state) {
+  return {
+    sourceCount: state.sourceCount,
+    conceptCount: state.conceptCount,
+    queryCount: state.queryCount,
+    pendingCandidates: state.pendingCandidates,
+    hasIndex: state.hasIndex,
+    hasLintCache: state.lint.present,
+    lint: state.lint.entry
+  };
+}
+function renderHuman(state, recommendation) {
+  const lines = [];
+  lines.push("llmwiki next");
+  lines.push("------------");
+  lines.push("");
+  lines.push(`Project: ${state.root}`);
+  lines.push(`State: ${describeStateLine(state, recommendation.state)}`);
+  appendHumanRecommendation(lines, recommendation.recommended);
+  appendHumanOtherActions(lines, recommendation.otherActions);
+  appendHumanWarnings(lines, state.warnings);
+  return lines.join("\n");
+}
+function appendHumanRecommendation(lines, action) {
+  lines.push("");
+  lines.push("Recommended next action:");
+  lines.push(`  ${action.command ?? action.reason}`);
+}
+function appendHumanOtherActions(lines, actions) {
+  if (actions.length === 0) return;
+  lines.push("");
+  lines.push("Other useful actions:");
+  for (const action of actions) {
+    if (action.command) lines.push(`  ${action.command}`);
+  }
+}
+function appendHumanWarnings(lines, warnings) {
+  if (warnings.length === 0) return;
+  lines.push("");
+  lines.push("Notes:");
+  for (const warning of warnings) lines.push(`  - ${warning.message}`);
+}
+function describeStateLine(state, kind) {
+  return STATE_LINE_RENDERERS[kind](state);
+}
+function formatWikiReadyLine(state) {
+  return `wiki ready, ${pageTotal(state)} page${plural(pageTotal(state))}, ${state.pendingCandidates} pending candidate${plural(state.pendingCandidates)}`;
+}
+function formatLintAttentionLine(state) {
+  const entry = state.lint.entry;
+  if (!entry) return "lint cache reports errors";
+  return `lint reports ${entry.errors} error${plural(entry.errors)}, ${entry.warnings} warning${plural(entry.warnings)}`;
+}
+function pageTotal(state) {
+  return state.conceptCount + state.queryCount;
+}
+function plural(count) {
+  return count === 1 ? "" : "s";
+}
+
+// src/commands/quickstart.ts
+import path46 from "path";
+
+// src/utils/provider-guard.ts
+var PROVIDER_KEY_VARS = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  ollama: null,
+  minimax: "MINIMAX_API_KEY",
+  copilot: "GITHUB_TOKEN"
+};
+function ensureProviderAvailable() {
+  const provider = process.env.LLMWIKI_PROVIDER ?? DEFAULT_PROVIDER;
+  if (provider === "anthropic") {
+    const auth = resolveAnthropicAuthFromEnv();
+    if (!auth.apiKey && !auth.authToken) {
+      throw new Error(
+        `Anthropic credentials are required for the "anthropic" provider.
+  Set one of: export ANTHROPIC_API_KEY=<your-key> OR export ANTHROPIC_AUTH_TOKEN=<your-token>`
+      );
+    }
+    return;
+  }
+  const keyVar = PROVIDER_KEY_VARS[provider];
+  if (keyVar === void 0) {
+    throw new Error(
+      `Unknown provider "${provider}".
+  Supported: ${Object.keys(PROVIDER_KEY_VARS).join(", ")}`
+    );
+  }
+  if (keyVar && !process.env[keyVar]) {
+    throw new Error(
+      `${keyVar} environment variable is required for the "${provider}" provider.
+  Set it with: export ${keyVar}=<your-key>`
+    );
+  }
+}
+
+// src/commands/quickstart.ts
+var QUICKSTART_JSON_VERSION = 1;
+var VIEW_OPEN_ARGS_KEY = "view\0--open";
+var NOOP_RESTORE = () => {
+};
+async function quickstartCommand(source2, options = {}) {
+  const jsonMode = options.json === true;
+  setQuiet(jsonMode);
+  const restoreEnv = applyEnvOverrides(options);
+  try {
+    return await runQuickstart(source2, options, jsonMode);
+  } finally {
+    restoreEnv();
+    setQuiet(false);
+  }
+}
+async function runQuickstart(source2, options, jsonMode) {
+  const root = process.cwd();
+  const ingest2 = await runIngestStep(source2);
+  if (!ingest2.ok) {
+    return finalizeFailure({ source: source2, ingest: ingest2, jsonMode });
+  }
+  const compile2 = await runCompileStep(root, options.review === true);
+  const viewer = buildViewerEnvelope();
+  const run = { source: source2, ingest: ingest2, compile: compile2, viewer };
+  return await finalizeSuccess(run, options, jsonMode, root);
+}
+function applyEnvOverrides(options) {
+  return combineRestorers([
+    applyProviderOverride(options.provider),
+    applyLanguageOverride(options.lang)
+  ]);
+}
+function combineRestorers(restorers) {
+  return () => {
+    for (const restore of restorers) restore();
+  };
+}
+function applyProviderOverride(provider) {
+  const trimmed = provider?.trim();
+  if (!trimmed) return NOOP_RESTORE;
+  const restore = snapshotEnv("LLMWIKI_PROVIDER");
+  process.env.LLMWIKI_PROVIDER = trimmed;
+  return restore;
+}
+function applyLanguageOverride(lang) {
+  const trimmed = lang?.trim();
+  if (!trimmed) return NOOP_RESTORE;
+  const restore = snapshotEnv("LLMWIKI_OUTPUT_LANG");
+  applyLanguageOption(trimmed);
+  return restore;
+}
+function snapshotEnv(name) {
+  const previous = process.env[name];
+  return () => {
+    if (previous === void 0) {
+      delete process.env[name];
+    } else {
+      process.env[name] = previous;
+    }
+  };
+}
+async function runIngestStep(source2) {
+  header("llmwiki quickstart");
+  status("*", info(`Ingesting ${source2}`));
+  try {
+    const result = await ingestSource(source2);
+    const relPath = path46.join(SOURCES_DIR, result.filename);
+    status("+", success(`Ingested \u2192 ${relPath}`));
+    return buildIngestSuccess(result, relPath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    status("!", error(`Ingest failed: ${message}`));
+    return buildIngestFailure(message);
+  }
+}
+function buildIngestSuccess(result, relPath) {
+  return {
+    ok: true,
+    path: relPath,
+    sourceType: result.sourceType ?? null,
+    error: null
+  };
+}
+function buildIngestFailure(message) {
+  return {
+    ok: false,
+    path: null,
+    sourceType: null,
+    error: { code: "ingest_failed", message, recoverable: false }
+  };
+}
+function emptyCompileEnvelope() {
+  return {
+    ok: false,
+    compiled: 0,
+    skipped: 0,
+    deleted: 0,
+    pendingCandidates: 0,
+    errors: null,
+    error: null
+  };
+}
+var COMPILE_ERROR_LABEL = {
+  provider_unavailable: "Compile prerequisite",
+  compile_failed: "Compile"
+};
+async function buildCompileFailureEnvelope(root, code, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  status("!", error(`${COMPILE_ERROR_LABEL[code]} failed: ${message}`));
+  return {
+    ...emptyCompileEnvelope(),
+    pendingCandidates: await safeCountCandidates2(root),
+    error: { code, message, recoverable: true }
+  };
+}
+async function runCompileStep(root, review) {
+  try {
+    ensureProviderAvailable();
+  } catch (err) {
+    return await buildCompileFailureEnvelope(root, "provider_unavailable", err);
+  }
+  try {
+    const result = await compileAndReport(root, { review });
+    return await buildCompileEnvelopeFromResult(root, result);
+  } catch (err) {
+    return await buildCompileFailureEnvelope(root, "compile_failed", err);
+  }
+}
+async function buildCompileEnvelopeFromResult(root, result) {
+  const pendingCandidates = await safeCountCandidates2(root);
+  const hasErrors = result.errors.length > 0;
+  return {
+    ok: !hasErrors,
+    compiled: result.compiled,
+    skipped: result.skipped,
+    deleted: result.deleted,
+    pendingCandidates,
+    errors: hasErrors ? [...result.errors] : [],
+    error: null
+  };
+}
+async function safeCountCandidates2(root) {
+  try {
+    return await countCandidates(root);
+  } catch {
+    return 0;
+  }
+}
+function buildViewerEnvelope() {
+  return { opened: false, url: null };
+}
+function finalizeFailure(ctx) {
+  const compile2 = emptyCompileEnvelope();
+  const next = {
+    command: `llmwiki ingest ${ctx.source}`,
+    reason: "Source could not be ingested. Inspect the input and rerun ingest.",
+    executable: { binary: "llmwiki", args: ["ingest"], placeholders: ["source"] }
+  };
+  const envelope = {
+    version: QUICKSTART_JSON_VERSION,
+    source: ctx.source,
+    ingest: ctx.ingest,
+    compile: compile2,
+    viewer: buildViewerEnvelope(),
+    next
+  };
+  emitEnvelope(envelope, ctx.jsonMode);
+  return 1;
+}
+async function finalizeSuccess(run, options, jsonMode, root) {
+  const projectState = await safeCollectState(root);
+  const next = deriveNextAction(run, options, projectState);
+  const handoff = shouldStartViewer({ options, jsonMode, compile: run.compile, projectState });
+  const envelope = buildSuccessEnvelope(run, suppressRedundantViewerNext(next, handoff));
+  emitEnvelope(envelope, jsonMode);
+  if (handoff) await handoffToViewer();
+  return 0;
+}
+function buildSuccessEnvelope(run, next) {
+  return {
+    version: QUICKSTART_JSON_VERSION,
+    source: run.source,
+    ingest: run.ingest,
+    compile: run.compile,
+    viewer: run.viewer,
+    next
+  };
+}
+async function safeCollectState(root) {
+  try {
+    return await collectProjectState(root);
+  } catch {
+    return null;
+  }
+}
+function deriveNextAction(run, options, projectState) {
+  if (options.review === true && run.compile.ok) return reviewListAction();
+  if (!run.compile.ok) return resumeCompileAction(run.compile);
+  return postCompileRecommendation(projectState);
+}
+function reviewListAction() {
+  return {
+    command: "llmwiki review list",
+    reason: "Generated candidates are waiting for review.",
+    executable: { binary: "llmwiki", args: ["review", "list"] }
+  };
+}
+function resumeCompileAction(compile2) {
+  const reason = compile2.error ? "Source was ingested, but compile did not complete." : "Compile reported errors. Address them and rerun compile.";
+  return {
+    command: "llmwiki compile",
+    reason,
+    executable: { binary: "llmwiki", args: ["compile"] }
+  };
+}
+function postCompileRecommendation(projectState) {
+  if (!projectState) {
+    return {
+      command: "llmwiki view --open",
+      reason: "Wiki pages are ready to browse.",
+      executable: { binary: "llmwiki", args: ["view", "--open"] }
+    };
+  }
+  const { recommended } = recommendNextAction(projectState);
+  return {
+    command: recommended.command,
+    reason: recommended.reason,
+    executable: recommended.executable
+  };
+}
+var VIEWER_HANDOFF_BLOCKERS = [
+  (gate) => gate.jsonMode,
+  (gate) => gate.options.open === false,
+  (gate) => gate.options.review === true,
+  (gate) => !gate.compile.ok,
+  (gate) => !hasRenderablePages(gate.projectState)
+];
+function shouldStartViewer(gate) {
+  return VIEWER_HANDOFF_BLOCKERS.every((isBlocked) => !isBlocked(gate));
+}
+function hasRenderablePages(state) {
+  return conceptCountOf(state) + queryCountOf(state) > 0;
+}
+function conceptCountOf(state) {
+  return state === null ? 0 : state.conceptCount;
+}
+function queryCountOf(state) {
+  return state === null ? 0 : state.queryCount;
+}
+function suppressRedundantViewerNext(next, handoff) {
+  if (!handoff) return next;
+  if (!isViewOpenAction(next)) return next;
+  return { command: null, reason: next.reason, executable: null };
+}
+function isViewOpenAction(next) {
+  return next.executable?.args.join("\0") === VIEW_OPEN_ARGS_KEY;
+}
+async function handoffToViewer() {
+  process.stdout.write("\nStarting viewer. Press Ctrl+C to stop.\n");
+  await viewCommand({ open: true });
+}
+function emitEnvelope(envelope, jsonMode) {
+  if (jsonMode) {
+    process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+    return;
+  }
+  renderHuman2(envelope);
+}
+function renderHuman2(envelope) {
+  const lines = [];
+  appendIngestLine(lines, envelope.ingest);
+  appendCompileLines(lines, envelope.compile);
+  appendNextLines(lines, envelope.next);
+  process.stdout.write(`
+${lines.join("\n")}
+`);
+}
+function appendIngestLine(lines, ingest2) {
+  if (ingest2.ok && ingest2.path) {
+    lines.push(`1. Ingested source \u2192 ${ingest2.path}`);
+    return;
+  }
+  lines.push("1. Ingest failed \u2014 see error above.");
+}
+function appendCompileLines(lines, compile2) {
+  const rule = COMPILE_LINE_RULES.find((candidate) => candidate.matches(compile2));
+  if (rule) lines.push(rule.render(compile2));
+}
+var COMPILE_LINE_RULES = [
+  {
+    matches: (compile2) => compile2.error !== null,
+    render: () => "2. Compile did not complete."
+  },
+  {
+    matches: (compile2) => (compile2.errors?.length ?? 0) > 0,
+    render: (compile2) => `2. Compile reported ${compile2.errors?.length ?? 0} error(s).`
+  },
+  {
+    matches: (compile2) => compile2.ok && compile2.pendingCandidates > 0,
+    render: (compile2) => `2. Compiled review candidates \u2192 ${compile2.pendingCandidates} pending`
+  },
+  {
+    matches: (compile2) => compile2.ok,
+    render: (compile2) => `2. Compiled wiki \u2192 ${compile2.compiled} new, ${compile2.skipped} skipped`
+  }
+];
+function appendNextLines(lines, next) {
+  if (!next.command) return;
+  lines.push("");
+  lines.push("Next:");
+  lines.push(`  ${next.command}`);
+}
+
+// src/commands/context.ts
+import path48 from "path";
+
+// src/context/provenance.ts
+import { promises as fs } from "fs";
+import path47 from "path";
+var MAX_SOURCE_WINDOWS = 20;
+var MAX_LINES_PER_WINDOW = 30;
+var CITATION_KEY_SEPARATOR = " <#> ";
+function flattenCitations(citations) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const citation of citations) {
+    for (const span of citation.spans) {
+      const flat = toFlatCitation(span);
+      const key = citationKey(flat);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(flat);
+    }
+  }
+  return out;
+}
+function toFlatCitation(span) {
+  if (!span.lines) return { file: span.file };
+  return { file: span.file, start: span.lines.start, end: span.lines.end };
+}
+function citationKey(citation) {
+  const start = citation.start ?? "-";
+  const end = citation.end ?? "-";
+  return [citation.file, String(start), String(end)].join(CITATION_KEY_SEPARATOR);
+}
+function createSourceWindowBudget() {
+  return { remaining: MAX_SOURCE_WINDOWS };
+}
+async function materializeSourceWindows(root, citations, budget) {
+  if (budget.remaining <= 0) return [];
+  const windows = [];
+  for (const citation of citations) {
+    if (budget.remaining <= 0) break;
+    if (citation.start === void 0 || citation.end === void 0) continue;
+    const window = await readSourceWindow(root, citation);
+    if (!window) continue;
+    windows.push(window);
+    budget.remaining -= 1;
+  }
+  return windows;
+}
+async function readSourceWindow(root, citation) {
+  if (citation.start === void 0 || citation.end === void 0) return null;
+  const sourcesRoot = await resolveSourcesRoot(root);
+  if (!sourcesRoot) return null;
+  const realPath = await resolveSafePath(sourcesRoot, citation.file);
+  if (!realPath) return null;
+  return readClampedWindow(realPath, citation);
+}
+async function resolveSourcesRoot(root) {
+  const candidate = path47.join(root, SOURCES_DIR);
+  try {
+    return await fs.realpath(candidate);
+  } catch {
+    return null;
+  }
+}
+async function resolveSafePath(sourcesRoot, file) {
+  if (file.length === 0) return null;
+  if (path47.isAbsolute(file)) return null;
+  if (containsParentSegment2(file)) return null;
+  const joined = path47.join(sourcesRoot, file);
+  const resolved = path47.resolve(joined);
+  if (!isInside2(sourcesRoot, resolved)) return null;
+  try {
+    const realPath = await fs.realpath(resolved);
+    if (!isInside2(sourcesRoot, realPath)) return null;
+    return realPath;
+  } catch {
+    return null;
+  }
+}
+function containsParentSegment2(file) {
+  const segments = file.split(/[/\\]/);
+  return segments.some((segment) => segment === "..");
+}
+function isInside2(parent, candidate) {
+  if (candidate === parent) return true;
+  const normalizedParent = parent.endsWith(path47.sep) ? parent : `${parent}${path47.sep}`;
+  return candidate.startsWith(normalizedParent);
+}
+async function readClampedWindow(realPath, citation) {
+  if (citation.start === void 0 || citation.end === void 0) return null;
+  let raw;
+  try {
+    raw = await fs.readFile(realPath, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = raw.split(/\r?\n/);
+  const startIndex = Math.max(0, citation.start - 1);
+  const inclusiveEnd = Math.min(lines.length, citation.end);
+  if (startIndex >= inclusiveEnd) return null;
+  const clampedEnd = Math.min(inclusiveEnd, startIndex + MAX_LINES_PER_WINDOW);
+  const text = lines.slice(startIndex, clampedEnd).join("\n");
+  return { file: citation.file, start: citation.start, end: startIndex + (clampedEnd - startIndex), text };
+}
+
+// src/context/ranking.ts
+var WEIGHT_TITLE_MATCH = 0.5;
+var WEIGHT_BODY_MATCH = 0.3;
+var WEIGHT_EXACT_SLUG = 0.4;
+var WEIGHT_EXACT_TITLE = 0.5;
+var WEIGHT_SEMANTIC_CHUNK = 0.5;
+var WEIGHT_SEMANTIC_CHUNK_BONUS = 0.05;
+var MAX_SEMANTIC_BONUS_CHUNKS = 3;
+var MAX_NORMALIZED_SCORE = 1;
+function rankPages(snapshot, prompt, topN, semanticHits = []) {
+  const rows = /* @__PURE__ */ new Map();
+  applyLexicalSignals(rows, snapshot, prompt);
+  applyExactSignals(rows, snapshot, prompt);
+  applySemanticSignals(rows, snapshot, semanticHits);
+  const sorted = Array.from(rows.values()).sort(compareRows);
+  return sorted.slice(0, Math.max(0, topN)).map(rowToPrimary);
+}
+function applyLexicalSignals(rows, snapshot, prompt) {
+  const { results } = searchPages(snapshot, prompt);
+  for (const result of results) {
+    const page = snapshot.pages.find((p) => p.id === result.id);
+    if (!page) continue;
+    const row = ensureRow(rows, page);
+    row.snippet = row.snippet || result.snippet;
+    if (result.matchedIn === "title") {
+      addReason(row, "title-match", WEIGHT_TITLE_MATCH);
+    } else {
+      addReason(row, "body-match", WEIGHT_BODY_MATCH);
+    }
+  }
+}
+function applyExactSignals(rows, snapshot, prompt) {
+  const normalized = prompt.trim().toLowerCase();
+  if (normalized.length === 0) return;
+  for (const page of snapshot.pages) {
+    if (page.slug.toLowerCase() === normalized) {
+      addReason(ensureRow(rows, page), "exact-slug", WEIGHT_EXACT_SLUG);
+    }
+    if (page.title.trim().toLowerCase() === normalized) {
+      addReason(ensureRow(rows, page), "exact-title", WEIGHT_EXACT_TITLE);
+    }
+  }
+}
+function applySemanticSignals(rows, snapshot, hits) {
+  if (hits.length === 0) return;
+  const bySlug = groupHitsBySlug(hits);
+  for (const [slug, slugHits] of bySlug) {
+    const page = findPageBySlug(snapshot, slug);
+    if (!page) continue;
+    const row = ensureRow(rows, page);
+    addReason(row, "semantic-chunk", WEIGHT_SEMANTIC_CHUNK);
+    row.weight += semanticMultiChunkBonus(slugHits.length);
+    for (const hit of slugHits) {
+      row.chunks.push({
+        text: hit.text,
+        score: hit.score,
+        contentHash: hit.contentHash
+      });
+    }
+  }
+}
+function groupHitsBySlug(hits) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    const existing = bySlug.get(hit.slug);
+    if (existing) existing.push(hit);
+    else bySlug.set(hit.slug, [hit]);
+  }
+  return bySlug;
+}
+function semanticMultiChunkBonus(chunkCount) {
+  const extra = Math.max(0, Math.min(chunkCount - 1, MAX_SEMANTIC_BONUS_CHUNKS));
+  return extra * WEIGHT_SEMANTIC_CHUNK_BONUS;
+}
+function findPageBySlug(snapshot, slug) {
+  const concept = snapshot.pages.find(
+    (p) => p.pageDirectory === "concepts" && p.slug === slug
+  );
+  if (concept) return concept;
+  const query = snapshot.pages.find(
+    (p) => p.pageDirectory === "queries" && p.slug === slug
+  );
+  return query ?? null;
+}
+function ensureRow(rows, page) {
+  const existing = rows.get(page.id);
+  if (existing) return existing;
+  const created = {
+    page,
+    reasons: /* @__PURE__ */ new Set(),
+    weight: 0,
+    snippet: "",
+    chunks: []
+  };
+  rows.set(page.id, created);
+  return created;
+}
+function addReason(row, reason, weight) {
+  row.reasons.add(reason);
+  row.weight += weight;
+}
+function compareRows(a, b) {
+  if (a.weight !== b.weight) return b.weight - a.weight;
+  const byTitle = a.page.title.localeCompare(b.page.title);
+  if (byTitle !== 0) return byTitle;
+  return a.page.id.localeCompare(b.page.id);
+}
+function rowToPrimary(row) {
+  return {
+    id: row.page.id,
+    title: row.page.title,
+    pageDirectory: row.page.pageDirectory,
+    score: normalizeWeight(row.weight),
+    reasons: Array.from(row.reasons).sort(),
+    summary: row.snippet,
+    chunks: row.chunks,
+    citations: flattenCitations(row.page.citations),
+    sourceWindows: [],
+    warnings: row.page.warnings.map((w) => ({ code: w.code, message: w.message }))
+  };
+}
+function normalizeWeight(weight) {
+  if (weight <= 0) return 0;
+  if (weight >= MAX_NORMALIZED_SCORE) return MAX_NORMALIZED_SCORE;
+  return Math.round(weight * 100) / 100;
+}
+
+// src/context/retrieval.ts
+async function retrieveSemanticChunks(root, prompt, topChunks) {
+  if (topChunks <= 0) return emptyOutcome(null);
+  if (await isStoreUnusable(root)) return emptyOutcome("embedding-store-missing");
+  let raw;
+  try {
+    raw = await findRelevantChunks(root, prompt, topChunks);
+  } catch (err) {
+    return emptyOutcome(classifyRetrievalError(err));
+  }
+  if (raw.length === 0) {
+    return emptyOutcome("embedding-store-missing");
+  }
+  return { hits: raw.map(toSemanticChunkHit), warning: null };
+}
+function emptyOutcome(warning) {
+  return { hits: [], warning };
+}
+async function isStoreUnusable(root) {
+  const store = await tryReadEmbeddingStore(root);
+  if (!store) return true;
+  if (!store.chunks || store.chunks.length === 0) return true;
+  if (isStaleModel(store)) return true;
+  return false;
+}
+async function tryReadEmbeddingStore(root) {
+  try {
+    return await readEmbeddingStore(root);
+  } catch {
+    return null;
+  }
+}
+function isStaleModel(store) {
+  try {
+    return store.model !== resolveEmbeddingModel();
+  } catch {
+    return true;
+  }
+}
+function classifyRetrievalError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return looksLikeProviderFailure(message) ? "query-embedding-unavailable" : "semantic-retrieval-error";
+}
+function looksLikeProviderFailure(message) {
+  return /api[_ -]?key|auth|credential|token|provider|voyage|openai|ollama|timeout|fetch|econn|enotfound/i.test(message);
+}
+function toSemanticChunkHit(raw) {
+  return {
+    slug: raw.chunk.slug,
+    text: raw.chunk.text,
+    score: raw.score,
+    contentHash: raw.chunk.contentHash
+  };
+}
+
+// src/context/graph.ts
+var NEIGHBOR_REASON_WIKILINK = "wikilink";
+var CANONICAL_PAIR_SEPARATOR = " <-> ";
+var MAX_GRAPH_NEIGHBORS = 20;
+var WEIGHT_NEIGHBOR_DIRECT = 0.5;
+var WEIGHT_NEIGHBOR_SECOND_HOP = 0.25;
+var WEIGHT_PRIMARY_CONNECTION_BONUS = 0.05;
+var MAX_PRIMARY_CONNECTION_BONUS_HITS = 3;
+var WEIGHT_SAME_KIND_BONUS = 0.03;
+var DEFAULT_PAGE_KIND = "concept";
+var MAX_NORMALIZED_SCORE2 = 1;
+function expandGraphNeighborhood(input) {
+  if (input.depth <= 0 || input.primaryIds.size === 0) {
+    return { neighbors: [], gaps: [] };
+  }
+  const adjacency = buildAdjacency(input.graph);
+  const ghostIds = collectGhostIds(input.graph.nodes);
+  const pageKinds = buildPageKindMap(input.pages);
+  const depth1Raw = expandDepthOne({
+    primaryIds: input.primaryIds,
+    adjacency,
+    ghostIds,
+    pageKinds
+  });
+  const depth1 = depth1Raw.sort(compareNeighbors).slice(0, MAX_GRAPH_NEIGHBORS);
+  const depth2 = input.depth >= 2 ? expandDepthTwo({
+    primaryIds: input.primaryIds,
+    adjacency,
+    ghostIds,
+    pageKinds,
+    depthOneTargets: collectDepthOneTargets(depth1)
+  }) : [];
+  const neighbors = [...depth1, ...depth2].sort(compareNeighbors).slice(0, MAX_GRAPH_NEIGHBORS);
+  return { neighbors, gaps: emitGapsFromPrimary(input) };
+}
+function emitGapsFromPrimary(input) {
+  const gaps = [];
+  for (const page of input.pages) {
+    if (!input.primaryIds.has(page.id)) continue;
+    for (const dangling of page.danglingLinks ?? []) {
+      gaps.push({
+        code: "dangling-link",
+        message: `Page links to [[${dangling.display}]], but no page exists.`,
+        pageId: page.id
+      });
+    }
+  }
+  return gaps;
+}
+function buildAdjacency(graph) {
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    addToSetMap(outgoing, edge.source, edge.target);
+    addToSetMap(incoming, edge.target, edge.source);
+  }
+  return { outgoing, incoming };
+}
+function addToSetMap(map, key, value) {
+  const existing = map.get(key);
+  if (existing) existing.add(value);
+  else map.set(key, /* @__PURE__ */ new Set([value]));
+}
+function collectGhostIds(nodes) {
+  const ghosts = /* @__PURE__ */ new Set();
+  for (const node of nodes) if (node.isDangling) ghosts.add(node.id);
+  return ghosts;
+}
+function expandDepthOne(input) {
+  const emitted = /* @__PURE__ */ new Map();
+  const connectionCount = /* @__PURE__ */ new Map();
+  for (const primary of input.primaryIds) {
+    addNeighborsForPrimary({ ...input, primary, emitted, connectionCount });
+  }
+  applyPrimaryConnectionBonus(emitted, connectionCount);
+  return Array.from(emitted.values());
+}
+function addNeighborsForPrimary(ctx) {
+  walkIncidentEdges(ctx.adjacency, ctx.primary, (other, direction) => {
+    tryEmitDirect({ ctx, other, direction });
+  });
+}
+function tryEmitDirect(input) {
+  const { ctx, other, direction } = input;
+  if (ctx.ghostIds.has(other)) return;
+  if (ctx.primaryIds.has(other)) return;
+  bumpConnection(ctx.connectionCount, other);
+  mergeOrInsertNeighbor(ctx.emitted, {
+    from: ctx.primary,
+    to: other,
+    direction,
+    distance: 1,
+    score: scoreWithSameKindBonus(
+      WEIGHT_NEIGHBOR_DIRECT,
+      ctx.primary,
+      other,
+      ctx.pageKinds
+    )
+  });
+}
+function bumpConnection(counter, target) {
+  counter.set(target, (counter.get(target) ?? 0) + 1);
+}
+var EMPTY_NEIGHBOR_SET = /* @__PURE__ */ new Set();
+function walkIncidentEdges(adjacency, node, onEdge) {
+  const outgoing = adjacency.outgoing.get(node) ?? EMPTY_NEIGHBOR_SET;
+  const incoming = adjacency.incoming.get(node) ?? EMPTY_NEIGHBOR_SET;
+  for (const target of outgoing) onEdge(target, "outgoing");
+  for (const source2 of incoming) onEdge(source2, "incoming");
+}
+function mergeOrInsertNeighbor(emitted, candidate) {
+  const key = canonicalPairKey(candidate.from, candidate.to);
+  const existing = emitted.get(key);
+  if (existing) {
+    if (existing.direction === "incoming" && candidate.direction === "outgoing") {
+      existing.direction = "outgoing";
+    }
+    return;
+  }
+  emitted.set(key, { ...candidate, reason: NEIGHBOR_REASON_WIKILINK });
+}
+function applyPrimaryConnectionBonus(emitted, connectionCount) {
+  for (const neighbor of emitted.values()) {
+    const hits = connectionCount.get(neighbor.to) ?? 0;
+    const extraHits = Math.min(
+      Math.max(0, hits - 1),
+      MAX_PRIMARY_CONNECTION_BONUS_HITS
+    );
+    neighbor.score = clampScore(
+      neighbor.score + extraHits * WEIGHT_PRIMARY_CONNECTION_BONUS
+    );
+  }
+}
+function expandDepthTwo(input) {
+  const emitted = /* @__PURE__ */ new Map();
+  for (const bridge of input.depthOneTargets) {
+    walkDepthTwoFromBridge({ ...input, bridge, emitted });
+  }
+  return Array.from(emitted.values());
+}
+function walkDepthTwoFromBridge(ctx) {
+  walkIncidentEdges(ctx.adjacency, ctx.bridge, (other, direction) => {
+    tryEmitSecondHop({ ctx, other, direction });
+  });
+}
+function tryEmitSecondHop(input) {
+  const { ctx, other, direction } = input;
+  if (ctx.ghostIds.has(other)) return;
+  if (ctx.primaryIds.has(other)) return;
+  if (ctx.depthOneTargets.has(other)) return;
+  mergeOrInsertNeighbor(ctx.emitted, {
+    from: ctx.bridge,
+    to: other,
+    direction,
+    distance: 2,
+    score: scoreWithSameKindBonus(
+      WEIGHT_NEIGHBOR_SECOND_HOP,
+      ctx.bridge,
+      other,
+      ctx.pageKinds
+    )
+  });
+}
+function buildPageKindMap(pages) {
+  const kinds = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const kind = page.frontmatter.kind;
+    kinds.set(page.id, typeof kind === "string" && kind.length > 0 ? kind : DEFAULT_PAGE_KIND);
+  }
+  return kinds;
+}
+function scoreWithSameKindBonus(base, from, to, pageKinds) {
+  return samePageKind(from, to, pageKinds) ? clampScore(base + WEIGHT_SAME_KIND_BONUS) : base;
+}
+function samePageKind(from, to, pageKinds) {
+  const fromKind = pageKinds.get(from);
+  const toKind = pageKinds.get(to);
+  return fromKind !== void 0 && toKind !== void 0 && fromKind === toKind;
+}
+function collectDepthOneTargets(neighbors) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const n of neighbors) ids.add(n.to);
+  return ids;
+}
+function canonicalPairKey(a, b) {
+  return a < b ? `${a}${CANONICAL_PAIR_SEPARATOR}${b}` : `${b}${CANONICAL_PAIR_SEPARATOR}${a}`;
+}
+function clampScore(weight) {
+  if (weight <= 0) return 0;
+  if (weight >= MAX_NORMALIZED_SCORE2) return MAX_NORMALIZED_SCORE2;
+  return Math.round(weight * 100) / 100;
+}
+function compareNeighbors(a, b) {
+  if (a.score !== b.score) return b.score - a.score;
+  return a.to.localeCompare(b.to);
+}
+
+// src/context/budget.ts
+var APPROX_CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  if (text === null || text === void 0) return 0;
+  const stringified = typeof text === "string" ? text : String(text);
+  if (stringified.length === 0) return 0;
+  return Math.ceil(stringified.length / APPROX_CHARS_PER_TOKEN);
+}
+function estimatePackTokens(pack) {
+  return estimateTokens(JSON.stringify(pack));
+}
+function buildBudget(requestedTokens, estimatedTokens) {
+  return {
+    requestedTokens,
+    estimatedTokens,
+    truncated: false,
+    trimmedSections: []
+  };
+}
+function trimToBudget(pack, requestedTokens) {
+  const clone = clonePack(pack);
+  const trimmed = /* @__PURE__ */ new Set();
+  if (estimatePackTokens(clone) <= requestedTokens) {
+    return { pack: clone, trimmedSections: [] };
+  }
+  trimNeighbors(clone, requestedTokens, trimmed);
+  trimSourceWindows(clone, requestedTokens, trimmed);
+  trimChunks(clone, requestedTokens, trimmed);
+  trimPrimary(clone, requestedTokens, trimmed);
+  return { pack: clone, trimmedSections: orderedSections(trimmed) };
+}
+function clonePack(pack) {
+  return structuredClone(pack);
+}
+function orderedSections(trimmed) {
+  const order = ["neighbors", "sourceWindows", "chunks", "primary"];
+  return order.filter((section) => trimmed.has(section));
+}
+function trimNeighbors(pack, budget, trimmed) {
+  while (pack.neighbors.length > 0 && estimatePackTokens(pack) > budget) {
+    pack.neighbors.pop();
+    trimmed.add("neighbors");
+  }
+}
+function trimSourceWindows(pack, budget, trimmed) {
+  for (let i = pack.primary.length - 1; i >= 0; i--) {
+    while (pack.primary[i].sourceWindows.length > 0 && estimatePackTokens(pack) > budget) {
+      pack.primary[i].sourceWindows.pop();
+      trimmed.add("sourceWindows");
+    }
+    if (estimatePackTokens(pack) <= budget) return;
+  }
+}
+function trimChunks(pack, budget, trimmed) {
+  for (let i = pack.primary.length - 1; i >= 0; i--) {
+    while (pack.primary[i].chunks.length > 0 && estimatePackTokens(pack) > budget) {
+      pack.primary[i].chunks.pop();
+      trimmed.add("chunks");
+    }
+    if (estimatePackTokens(pack) <= budget) return;
+  }
+}
+function trimPrimary(pack, budget, trimmed) {
+  while (pack.primary.length > 0 && estimatePackTokens(pack) > budget) {
+    pack.primary.pop();
+    trimmed.add("primary");
+  }
+}
+
+// src/context/types.ts
+var PROMPT_ECHO_MAX_LENGTH = 1024;
+var DEFAULT_BUDGET_TOKENS = 8e3;
+var DEFAULT_DEPTH = 1;
+var MAX_DEPTH = 2;
+var DEFAULT_TOP_PAGES = 5;
+var MAX_TOP_PAGES = 20;
+var DEFAULT_TOP_CHUNKS = 8;
+var MAX_TOP_CHUNKS = 50;
+
+// src/context/build.ts
+async function buildContextPack(options) {
+  const normalized = normalizeOptions(options);
+  const snapshot = await buildViewerSnapshot(options.root);
+  const state = await collectProjectState(options.root);
+  const recommendation = recommendNextAction(state);
+  const semantic = await retrieveSemanticChunks(
+    options.root,
+    normalized.rankingPrompt,
+    normalized.topChunks
+  );
+  const draft = assembleDraft({
+    snapshot,
+    state,
+    recommendation,
+    options: normalized,
+    semantic
+  });
+  const withSources = normalized.includeSources ? await attachSourceWindows(draft, options.root) : draft;
+  const withProjectWarnings = appendProjectWarnings(withSources, state, normalized);
+  const graph = normalized.neighborsEnabled && normalized.depth >= 1 ? snapshot.graph : null;
+  return finalizeBudget(withProjectWarnings, normalized.budget, graph);
+}
+async function attachSourceWindows(pack, root) {
+  const budget = createSourceWindowBudget();
+  const primary = [];
+  for (const entry of pack.primary) {
+    const windows = await materializeSourceWindows(root, entry.citations, budget);
+    primary.push({ ...entry, sourceWindows: windows });
+  }
+  return { ...pack, primary };
+}
+function normalizeOptions(options) {
+  const rankingPrompt = options.prompt ?? "";
+  const { display, truncated } = truncatePrompt(rankingPrompt);
+  return {
+    displayPrompt: display,
+    rankingPrompt,
+    budget: clampPositive(options.budget, DEFAULT_BUDGET_TOKENS),
+    depth: clampDepth(options.depth),
+    topPages: clampBounded(options.topPages, DEFAULT_TOP_PAGES, MAX_TOP_PAGES),
+    topChunks: clampBounded(options.topChunks, DEFAULT_TOP_CHUNKS, MAX_TOP_CHUNKS),
+    omitRoot: options.omitRoot === true,
+    // `--no-neighbors` is a Commander negated flag: absence means
+    // expansion is ON; only `options.neighbors === false` disables it.
+    neighborsEnabled: options.neighbors !== false,
+    includeSources: options.includeSources === true,
+    promptTruncated: truncated
+  };
+}
+function truncatePrompt(raw) {
+  if (raw.length <= PROMPT_ECHO_MAX_LENGTH) return { display: raw, truncated: false };
+  return { display: raw.slice(0, PROMPT_ECHO_MAX_LENGTH), truncated: true };
+}
+function clampPositive(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+function clampBounded(value, fallback, max) {
+  return Math.min(max, clampPositive(value, fallback));
+}
+function clampDepth(value) {
+  if (value === void 0 || !Number.isFinite(value)) return DEFAULT_DEPTH;
+  return Math.max(0, Math.min(MAX_DEPTH, Math.floor(value)));
+}
+function assembleDraft(input) {
+  const { snapshot, state, recommendation, options, semantic } = input;
+  const project = buildProject2(snapshot, state, options.omitRoot);
+  const primary = rankPages(snapshot, options.rankingPrompt, options.topPages, semantic.hits);
+  const graphEnabled = options.neighborsEnabled && options.depth >= 1;
+  const expansion = graphEnabled ? expandGraphNeighborhood({
+    graph: snapshot.graph,
+    pages: snapshot.pages,
+    primaryIds: collectPrimaryIds(primary),
+    depth: options.depth
+  }) : emptyExpansion();
+  const annotatedPrimary = graphEnabled ? annotateGraphNeighbors(primary, snapshot.graph) : primary;
+  return {
+    version: 1,
+    prompt: options.displayPrompt,
+    budget: buildBudget(options.budget, 0),
+    project,
+    primary: annotatedPrimary,
+    neighbors: expansion.neighbors,
+    warnings: buildTopLevelWarnings(options.promptTruncated, semantic.warning),
+    gaps: expansion.gaps,
+    suggestedActions: collectSuggestedActions(recommendation, {
+      hasPages: snapshot.pages.length > 0,
+      semanticWarning: semantic.warning
+    })
+  };
+}
+function annotateGraphNeighbors(primary, graph) {
+  if (primary.length < 2) return primary;
+  const primaryIds = collectPrimaryIds(primary);
+  const connected = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges) {
+    if (primaryIds.has(edge.source) && primaryIds.has(edge.target)) {
+      connected.add(edge.source);
+      connected.add(edge.target);
+    }
+  }
+  if (connected.size === 0) return primary;
+  return primary.map((entry) => {
+    if (!connected.has(entry.id)) return entry;
+    if (entry.reasons.includes("graph-neighbor")) return entry;
+    const widened = Array.from(/* @__PURE__ */ new Set([...entry.reasons, "graph-neighbor"])).sort();
+    return { ...entry, reasons: widened };
+  });
+}
+function collectPrimaryIds(primary) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const entry of primary) ids.add(entry.id);
+  return ids;
+}
+function stripGraphNeighborReason(primary) {
+  return primary.map((entry) => ({
+    ...entry,
+    reasons: entry.reasons.filter((reason) => reason !== "graph-neighbor")
+  }));
+}
+function reconcileGraphNeighborReasons(pack, graph) {
+  const stripped = stripGraphNeighborReason(pack.primary);
+  const primary = graph ? annotateGraphNeighbors(stripped, graph) : stripped;
+  return primary === pack.primary ? pack : { ...pack, primary };
+}
+function emptyExpansion() {
+  return { neighbors: [], gaps: [] };
+}
+function buildProject2(snapshot, state, omitRoot) {
+  return {
+    root: omitRoot ? null : snapshot.root,
+    pages: snapshot.pages.length,
+    pendingCandidates: state.pendingCandidates,
+    lint: state.lint.entry
+  };
+}
+function buildTopLevelWarnings(promptTruncated, retrievalWarning) {
+  const warnings = [];
+  if (promptTruncated) {
+    warnings.push({
+      code: "truncated-prompt",
+      message: `Prompt exceeded ${PROMPT_ECHO_MAX_LENGTH} characters; the echoed copy was truncated.`
+    });
+  }
+  if (retrievalWarning === "embedding-store-missing") {
+    warnings.push({
+      code: "embedding-store-missing",
+      message: "No usable embedding store found; semantic retrieval skipped. Run `llmwiki compile` to populate embeddings."
+    });
+  } else if (retrievalWarning === "query-embedding-unavailable") {
+    warnings.push({
+      code: "query-embedding-unavailable",
+      message: "Could not embed the prompt with the active provider; semantic retrieval skipped, lexical signals still applied."
+    });
+  } else if (retrievalWarning === "semantic-retrieval-error") {
+    warnings.push({
+      code: "semantic-retrieval-error",
+      message: "Semantic retrieval failed unexpectedly; lexical signals still applied and raw provider errors were not exposed."
+    });
+  }
+  return warnings;
+}
+var CONTEXT_COMPILE_ACTION = {
+  command: "llmwiki compile",
+  reason: "Refresh compiled pages and rebuild the embedding store for semantic context.",
+  executable: { binary: "llmwiki", args: ["compile"] }
+};
+var CONTEXT_VIEW_ACTION = {
+  command: "llmwiki view --open",
+  reason: "Browse the compiled wiki in the local viewer.",
+  executable: { binary: "llmwiki", args: ["view", "--open"] }
+};
+var CONTEXT_QUERY_ACTION = {
+  command: 'llmwiki query "<prompt>"',
+  reason: "Generate an answer with the same prompt after reviewing this context pack.",
+  executable: { binary: "llmwiki", args: ["query"], placeholders: ["prompt"] }
+};
+function collectSuggestedActions(recommendation, input) {
+  const actions = [];
+  for (const action of [recommendation.recommended, ...recommendation.otherActions]) {
+    appendUniqueAction(actions, action);
+  }
+  if (input.hasPages && input.semanticWarning === "embedding-store-missing") {
+    appendUniqueAction(actions, CONTEXT_COMPILE_ACTION);
+  }
+  if (input.hasPages) {
+    appendUniqueAction(actions, CONTEXT_VIEW_ACTION);
+    appendUniqueAction(actions, CONTEXT_QUERY_ACTION);
+  }
+  return actions;
+}
+function appendUniqueAction(actions, candidate) {
+  if (actions.some((action) => actionKey(action) === actionKey(candidate))) return;
+  actions.push(candidate);
+}
+function actionKey(action) {
+  if (!action.executable) return action.command ?? action.reason;
+  return `${action.executable.binary} ${action.executable.args.join(" ")}`;
+}
+function finalizeBudget(draft, requestedTokens, graph = null) {
+  const initialEstimate = estimatePackTokens(draft);
+  const trim = initialEstimate <= requestedTokens ? { pack: draft, trimmedSections: [] } : trimToBudget(draft, requestedTokens);
+  const trimmedAny = trim.trimmedSections.length > 0;
+  const reconciledPack = reconcileGraphNeighborReasons(trim.pack, graph);
+  const e1 = estimatePackTokens(
+    applyBudget(reconciledPack, {
+      requestedTokens,
+      estimatedTokens: 0,
+      truncated: trimmedAny,
+      trimmedSections: trim.trimmedSections
+    })
+  );
+  const e2 = estimatePackTokens(
+    applyBudget(reconciledPack, {
+      requestedTokens,
+      estimatedTokens: e1,
+      truncated: trimmedAny,
+      trimmedSections: trim.trimmedSections
+    })
+  );
+  const truncated = trimmedAny || e2 > requestedTokens;
+  return applyBudget(reconciledPack, {
+    requestedTokens,
+    estimatedTokens: e2,
+    truncated,
+    trimmedSections: trim.trimmedSections
+  });
+}
+function applyBudget(pack, budget) {
+  return { ...pack, budget };
+}
+function appendProjectWarnings(pack, state, options) {
+  const warnings = [...pack.warnings];
+  if (state.pendingCandidates > 0) {
+    warnings.push({
+      code: "pending-candidates",
+      message: `${state.pendingCandidates} review candidate${state.pendingCandidates === 1 ? "" : "s"} pending approval. Run \`llmwiki review list\` to inspect.`
+    });
   }
-  if (candidate.provenanceViolations && candidate.provenanceViolations.length > 0) {
-    console.log();
-    header("Provenance violations");
-    for (const v of candidate.provenanceViolations) {
-      status("!", warn(`[${v.severity}] ${v.message}`));
-    }
+  const lintErrors = state.lint.entry?.errors ?? 0;
+  if (lintErrors > 0) {
+    warnings.push({
+      code: "lint-errors",
+      message: `Last lint run reported ${lintErrors} error${lintErrors === 1 ? "" : "s"}.`
+    });
+  }
+  if (options.includeSources && hasUnmaterializedSpans(pack)) {
+    warnings.push({
+      code: "source-window-unavailable",
+      message: "One or more line-range citations did not produce a source window (path-confined, missing source file, or per-pack window cap reached)."
+    });
   }
+  return { ...pack, warnings };
+}
+function hasUnmaterializedSpans(pack) {
+  for (const entry of pack.primary) {
+    const lineRangeCount = entry.citations.filter(
+      (c) => c.start !== void 0 && c.end !== void 0
+    ).length;
+    if (lineRangeCount > entry.sourceWindows.length) return true;
+  }
+  return false;
 }
 
-// src/commands/review-approve.ts
-import path38 from "path";
-
-// src/commands/review-helpers.ts
-async function runReviewUnderLock(id, underLock) {
-  const root = process.cwd();
-  const preCheck = await loadCandidateOrFail(root, id);
-  if (!preCheck) return;
-  const locked = await acquireLock(root);
-  if (!locked) {
-    status("!", error("Could not acquire lock. Try again later."));
-    process.exitCode = 1;
+// src/commands/context.ts
+async function contextCommand(prompt, options = {}) {
+  const pack = await buildContextPack({
+    root: process.cwd(),
+    prompt,
+    budget: coerceNumber(options.budget, DEFAULT_BUDGET_TOKENS),
+    depth: coerceNumber(options.depth, DEFAULT_DEPTH),
+    topPages: coerceNumber(options.topPages, DEFAULT_TOP_PAGES),
+    topChunks: coerceNumber(options.topChunks, DEFAULT_TOP_CHUNKS),
+    omitRoot: options.omitRoot === true,
+    neighbors: options.neighbors,
+    includeSources: options.includeSources === true
+  });
+  emit(pack, resolveFormat(options));
+  return 0;
+}
+function coerceNumber(raw, fallback) {
+  if (raw === void 0) return fallback;
+  const value = typeof raw === "number" ? raw : Number(raw);
+  return Number.isFinite(value) ? value : fallback;
+}
+function resolveFormat(options) {
+  if (options.json === true) return "json";
+  if (options.format === "json") return "json";
+  return "markdown";
+}
+function emit(pack, format) {
+  if (format === "json") {
+    process.stdout.write(`${JSON.stringify(pack, null, 2)}
+`);
     return;
   }
-  try {
-    await underLock(root, id);
-  } finally {
-    await releaseLock(root);
+  process.stdout.write(`${renderMarkdown(pack)}
+`);
+}
+function renderMarkdown(pack) {
+  const lines = [];
+  appendHeader(lines, pack);
+  appendPrimaryPages(lines, pack.primary);
+  appendGraphNeighborhood(lines, pack.neighbors);
+  appendWarnings(lines, pack.warnings);
+  appendSuggestedActions(lines, pack.suggestedActions);
+  return lines.join("\n");
+}
+function appendGraphNeighborhood(lines, neighbors) {
+  if (neighbors.length === 0) return;
+  lines.push("## Graph Neighborhood");
+  lines.push("");
+  for (const neighbor of neighbors) {
+    const arrow = neighbor.direction === "outgoing" ? "->" : "<-";
+    lines.push(
+      `- \`${neighbor.from}\` ${arrow} \`${neighbor.to}\` (${neighbor.reason}, distance ${neighbor.distance})`
+    );
   }
+  lines.push("");
 }
-
-// src/commands/review-approve.ts
-async function reviewApproveCommand(id) {
-  await runReviewUnderLock(id, approveUnderLock);
+function appendHeader(lines, pack) {
+  lines.push("# Context Pack");
+  lines.push("");
+  lines.push(`Prompt: ${pack.prompt}`);
+  lines.push(`Budget: ${pack.budget.estimatedTokens} / ${pack.budget.requestedTokens} estimated tokens`);
 }
-async function approveUnderLock(root, id) {
-  const candidate = await loadCandidateUnderLockOrFail(root, id);
-  if (!candidate) return;
-  if (!validateWikiPage(candidate.body)) {
-    status("!", error(`Candidate ${id} failed page validation; not approved.`));
-    process.exitCode = 1;
+function appendPrimaryPages(lines, primary) {
+  lines.push("");
+  lines.push("## Primary Pages");
+  lines.push("");
+  if (primary.length === 0) {
+    lines.push("_No primary pages matched the prompt._");
     return;
   }
-  const pagePath = path38.join(root, CONCEPTS_DIR, `${candidate.slug}.md`);
-  await atomicWrite(pagePath, candidate.body);
-  status("+", success(`Approved \u2192 ${source(pagePath)}`));
-  await persistCandidateSourceStates(root, candidate);
-  await refreshWikiAfterApproval(root, candidate.slug);
-  await deleteCandidate(root, id);
-  status("\u2713", dim(`Candidate ${id} cleared.`));
+  for (const page of primary) appendPrimaryPage(lines, page);
 }
-async function persistCandidateSourceStates(root, candidate) {
-  const states = candidate.sourceStates;
-  if (!states) return;
-  const otherSources = await collectOtherCandidateSources(root, candidate.id);
-  for (const [sourceFile, entry] of Object.entries(states)) {
-    if (otherSources.has(sourceFile)) continue;
-    await updateSourceState(root, sourceFile, entry);
+function appendPrimaryPage(lines, page) {
+  const pageFile = path48.join("wiki", page.pageDirectory, `${slugFromId(page.id)}.md`);
+  lines.push(`### ${page.title} (\`${pageFile}\`)`);
+  lines.push("");
+  lines.push(`Why included: ${page.reasons.join(", ") || "(no signals)"}`);
+  if (page.summary) {
+    lines.push("");
+    lines.push(page.summary);
   }
+  appendCitations(lines, page);
+  appendSourceWindows(lines, page);
+  lines.push("");
 }
-async function collectOtherCandidateSources(root, approvingId) {
-  const pending = await listCandidates(root);
-  const sources = /* @__PURE__ */ new Set();
-  for (const candidate of pending) {
-    if (candidate.id === approvingId) continue;
-    for (const source2 of candidate.sources) sources.add(source2);
-  }
-  return sources;
+function appendCitations(lines, page) {
+  if (page.citations.length === 0) return;
+  const refs = page.citations.map(renderCitation).join(", ");
+  lines.push("");
+  lines.push(`Sources: ${refs}`);
 }
-async function refreshWikiAfterApproval(root, slug) {
-  await resolveLinks(root, [slug], [slug]);
-  await generateIndex(root);
-  await generateMOC(root);
-  await safelyUpdateEmbeddings2(root, [slug]);
+function renderCitation(citation) {
+  if (citation.start !== void 0 && citation.end !== void 0) {
+    return `\`${citation.file}:${citation.start}-${citation.end}\``;
+  }
+  return `\`${citation.file}\``;
 }
-async function safelyUpdateEmbeddings2(root, slugs) {
-  try {
-    await updateEmbeddings(root, slugs);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    status("!", warn(`Skipped embeddings update: ${message}`));
+function appendSourceWindows(lines, page) {
+  if (page.sourceWindows.length === 0) return;
+  for (const window of page.sourceWindows) {
+    lines.push("");
+    lines.push(`From \`${window.file}:${window.start}-${window.end}\`:`);
+    lines.push("");
+    for (const line2 of window.text.split(/\r?\n/)) lines.push(`> ${line2}`);
   }
 }
-
-// src/commands/review-reject.ts
-async function reviewRejectCommand(id) {
-  await runReviewUnderLock(id, rejectUnderLock);
+function slugFromId(id) {
+  const idx = id.indexOf("/");
+  return idx === -1 ? id : id.slice(idx + 1);
 }
-async function rejectUnderLock(root, id) {
-  const candidate = await loadCandidateUnderLockOrFail(root, id);
-  if (!candidate) return;
-  await archiveCandidate(root, id);
-  status(
-    "-",
-    warn(`Rejected candidate ${id} (${candidate.slug}) \u2014 archived, wiki unchanged.`)
-  );
+function appendWarnings(lines, warnings) {
+  if (warnings.length === 0) return;
+  lines.push("## Warnings");
+  lines.push("");
+  for (const warning of warnings) lines.push(`- ${warning.message}`);
+  lines.push("");
+}
+function appendSuggestedActions(lines, actions) {
+  if (actions.length === 0) return;
+  lines.push("## Suggested Next Actions");
+  lines.push("");
+  for (const action of actions) {
+    if (action.command) lines.push(`- \`${action.command}\``);
+  }
 }
 
 // src/mcp/server.ts
@@ -6036,42 +8667,8 @@ import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/tools.ts
-import path39 from "path";
+import path49 from "path";
 import { z } from "zod";
-
-// src/mcp/provider-check.ts
-var PROVIDER_KEY_VARS = {
-  anthropic: "ANTHROPIC_API_KEY",
-  openai: "OPENAI_API_KEY",
-  ollama: null,
-  minimax: "MINIMAX_API_KEY",
-  copilot: "GITHUB_TOKEN"
-};
-function ensureProviderAvailable() {
-  const provider = process.env.LLMWIKI_PROVIDER ?? DEFAULT_PROVIDER;
-  if (provider === "anthropic") {
-    const auth = resolveAnthropicAuthFromEnv();
-    if (!auth.apiKey && !auth.authToken) {
-      throw new Error(
-        'Anthropic credentials are required for the "anthropic" provider. Set ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN.'
-      );
-    }
-    return;
-  }
-  const keyVar = PROVIDER_KEY_VARS[provider];
-  if (keyVar === void 0) {
-    throw new Error(
-      `Unknown provider "${provider}". Supported: ${Object.keys(PROVIDER_KEY_VARS).join(", ")}`
-    );
-  }
-  if (keyVar && !process.env[keyVar]) {
-    throw new Error(
-      `${keyVar} environment variable is required for the "${provider}" provider.`
-    );
-  }
-}
-
-// src/mcp/tools.ts
 var PAGE_DIRS2 = [CONCEPTS_DIR, QUERIES_DIR];
 function jsonResult(payload) {
   return {
@@ -6087,6 +8684,7 @@ function registerWikiTools(server, root) {
   registerReadTool(server, root);
   registerLintTool(server, root);
   registerStatusTool(server, root);
+  registerContextPackTool(server, root);
 }
 function registerIngestTool(server, root) {
   server.registerTool(
@@ -6173,7 +8771,7 @@ async function pickSearchSlugs(root, question) {
     if (candidates.length > 0) return candidates.map((c) => c.slug);
   } catch {
   }
-  const indexContent = await safeReadFile(path39.join(root, INDEX_FILE));
+  const indexContent = await safeReadFile(path49.join(root, INDEX_FILE));
   const { pages } = await selectPages(question, indexContent);
   return pages;
 }
@@ -6231,9 +8829,48 @@ function registerStatusTool(server, root) {
     async () => jsonResult(await collectStatus(root))
   );
 }
+function registerContextPackTool(server, root) {
+  server.registerTool(
+    "get_context_pack",
+    contextPackToolConfig(),
+    async (args) => jsonResult(await buildContextPackFromArgs(root, args))
+  );
+}
+function contextPackToolConfig() {
+  return {
+    title: "Get Context Pack",
+    description: "Build an agent-ready evidence pack for `prompt` over the compiled wiki: primary pages, semantic chunks, graph neighbors, citations, warnings, and suggested next actions. Returns the same v1 JSON envelope as `llmwiki context --json`. Read-only; no provider credentials required. Use this to PREPARE evidence; use `query_wiki` to GENERATE a grounded natural-language answer.",
+    inputSchema: contextPackInputSchema()
+  };
+}
+function contextPackInputSchema() {
+  return {
+    prompt: z.string().describe("Free-text task or topic to assemble context for."),
+    budget: z.number().optional().describe("Approximate output token budget (default 8000)."),
+    depth: z.number().optional().describe("Graph neighborhood depth, 0..2 (default 1, 0 disables expansion)."),
+    topPages: z.number().optional().describe("Max primary pages (default 5, max 20)."),
+    topChunks: z.number().optional().describe("Max semantic chunks to surface (default 8, max 50)."),
+    omitRoot: z.boolean().optional().describe("Emit `project.root` as null instead of the absolute path."),
+    includeSources: z.boolean().optional().describe(
+      "Materialize `primary[].sourceWindows` from claim-level citations (reads files under `sources/` only; path-confined)."
+    )
+  };
+}
+async function buildContextPackFromArgs(root, args) {
+  return buildContextPack({
+    root,
+    prompt: args.prompt,
+    budget: args.budget,
+    depth: args.depth,
+    topPages: args.topPages,
+    topChunks: args.topChunks,
+    omitRoot: args.omitRoot,
+    includeSources: args.includeSources
+  });
+}
 async function collectStatus(root) {
-  const concepts = await collectPageSummaries(path39.join(root, CONCEPTS_DIR));
-  const queries = await collectPageSummaries(path39.join(root, QUERIES_DIR));
+  const concepts = await collectPageSummaries(path49.join(root, CONCEPTS_DIR));
+  const queries = await collectPageSummaries(path49.join(root, QUERIES_DIR));
   const state = await readState(root);
   const changes = await detectChanges(root, state);
   const orphans = await findOrphanedSlugs(root);
@@ -6250,7 +8887,7 @@ async function collectStatus(root) {
   };
 }
 async function findOrphanedSlugs(root) {
-  const scanned = await scanWikiPages(path39.join(root, CONCEPTS_DIR));
+  const scanned = await scanWikiPages(path49.join(root, CONCEPTS_DIR));
   return scanned.filter(({ meta }) => meta.orphaned).map(({ slug }) => slug);
 }
 async function loadPageRecords(root, slugs) {
@@ -6263,7 +8900,7 @@ async function loadPageRecords(root, slugs) {
 }
 async function readPage(root, slug) {
   for (const dir of PAGE_DIRS2) {
-    const content = await safeReadFile(path39.join(root, dir, `${slug}.md`));
+    const content = await safeReadFile(path49.join(root, dir, `${slug}.md`));
     if (!content) continue;
     const { meta, body } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -6278,8 +8915,8 @@ async function readPage(root, slug) {
 }
 
 // src/mcp/resources.ts
-import path40 from "path";
-import { readdir as readdir12 } from "fs/promises";
+import path50 from "path";
+import { readdir as readdir14 } from "fs/promises";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 function jsonContent(uri, payload) {
   return {
@@ -6312,7 +8949,7 @@ function registerIndexResource(server, root) {
       mimeType: "text/markdown"
     },
     async (uri) => {
-      const content = await safeReadFile(path40.join(root, INDEX_FILE));
+      const content = await safeReadFile(path50.join(root, INDEX_FILE));
       return { contents: [markdownContent(uri, content)] };
     }
   );
@@ -6379,23 +9016,23 @@ function registerQueryResource(server, root) {
   );
 }
 async function listSources(root) {
-  const sourcesPath = path40.join(root, SOURCES_DIR);
+  const sourcesPath = path50.join(root, SOURCES_DIR);
   let files;
   try {
-    files = await readdir12(sourcesPath);
+    files = await readdir14(sourcesPath);
   } catch {
     return [];
   }
   const records = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path40.join(sourcesPath, file));
+    const content = await safeReadFile(path50.join(sourcesPath, file));
     const { meta } = parseFrontmatter(content);
     records.push({ filename: file, ...meta });
   }
   return records;
 }
 async function loadPageWithMeta(root, dir, slug) {
-  const filePath = path40.join(root, dir, `${slug}.md`);
+  const filePath = path50.join(root, dir, `${slug}.md`);
   const content = await safeReadFile(filePath);
   if (!content) {
     throw new Error(`Page not found: ${dir}/${slug}.md`);
@@ -6404,10 +9041,10 @@ async function loadPageWithMeta(root, dir, slug) {
   return { slug, meta, body: body.trim() };
 }
 async function listPagesUnder(root, dir, scheme) {
-  const pagesPath = path40.join(root, dir);
+  const pagesPath = path50.join(root, dir);
   let files;
   try {
-    files = await readdir12(pagesPath);
+    files = await readdir14(pagesPath);
   } catch {
     return { resources: [] };
   }
@@ -6540,6 +9177,55 @@ program.command("lint").description("Run rule-based quality checks against the w
     process.exit(1);
   }
 });
+var evalCmd = program.command("eval").description("Evaluate wiki quality (health, citation coverage, LLM judge)").option("--suite <level>", "fast (deterministic) or full (+ LLM judge)", "fast").option("--out <format>", "terminal or json", "terminal").option("--sample <n>", "number of citations to judge in full suite", "20").action(async (opts) => {
+  try {
+    await evalCommand(opts);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+var evalCacheCmd = evalCmd.command("cache").description("Manage the citation judgement cache");
+evalCacheCmd.command("clear").description("Delete the cache so all judgements re-run on the next full eval").action(async () => {
+  try {
+    await evalCacheClearCommand();
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+evalCacheCmd.command("show").description("Print a score distribution summary of cached citation judgements").action(async () => {
+  try {
+    await evalCacheShowCommand();
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+evalCmd.command("report").description("Re-display the most recent eval report without running a new eval").option("--out <format>", "terminal or json", "terminal").action(async (opts) => {
+  try {
+    await evalReportCommand(opts);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+evalCmd.command("history").description("Show a trend table of past eval runs").option("--n <count>", "number of runs to show", "10").option("--out <format>", "terminal or json", "terminal").action(async (opts) => {
+  try {
+    await evalHistoryCommand(opts);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+evalCmd.command("judgements").description("Browse cached citation judgements").option("--score <0|1|2>", "filter by support score (0=unsupported, 1=partial, 2=full)").option("--page <slug>", "filter by wiki page slug").option("--n <count>", "limit number of judgements shown").option("--out <format>", "terminal or json", "terminal").action(async (opts) => {
+  try {
+    await evalJudgementsCommand(opts);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
 var schemaCmd = program.command("schema").description("Inspect or initialize the project's wiki schema config");
 schemaCmd.command("init").description("Write a starter schema file to .llmwiki/schema.json").action(async () => {
   try {
@@ -6568,6 +9254,28 @@ program.command("export").description("Export wiki content to portable formats (
     process.exit(1);
   }
 });
+program.command("next").description("Show the recommended next action for this llmwiki project (read-only)").option("--json", "Emit a stable JSON envelope for agent consumption").action(
+  async (options) => runExitCodeCommand(() => nextCommand({ json: options.json }))
+);
+program.command("context <prompt>").description(
+  "Build an agent-ready evidence pack for <prompt> from the compiled wiki (read-only; provider credentials optional \u2014 semantic retrieval is used when available and falls back to lexical otherwise)"
+).option("--budget <tokens>", "Approximate output token budget (default 8000)").option("--format <format>", "Output format: json | markdown (default markdown)").option("--json", "Emit the stable v1 JSON envelope (overrides --format)").option("--depth <n>", "Graph neighborhood depth, default 1, max 2; 0 disables expansion").option("--top-pages <n>", "Max primary pages (default 5, max 20)").option("--top-chunks <n>", "Max semantic chunks (default 8, max 50)").option("--omit-root", "Emit project.root as null for privacy").option("--no-neighbors", "Suppress graph expansion (keeps neighbors/gaps as empty arrays)").option(
+  "--include-sources",
+  "Populate primary[].sourceWindows from claim-level citation spans (max 20 windows, 30 lines each)"
+).action(
+  async (prompt, options) => runExitCodeCommand(() => contextCommand(prompt, options))
+);
+program.command("quickstart <source>").description(
+  "Ingest a source and compile it into a wiki in one step. Recommends the next action when finished."
+).option("--review", "Generate review candidates instead of mutating wiki/").option("--no-open", "Skip the viewer handoff after a successful compile").option(
+  "--provider <name>",
+  "Override LLMWIKI_PROVIDER for this run only (e.g. anthropic, openai, ollama)"
+).option(
+  "--lang <code>",
+  'Target language for generated wiki content (e.g. "Chinese", "ja", "zh-CN"). Equivalent to setting LLMWIKI_OUTPUT_LANG.'
+).option("--json", "Emit the quickstart JSON envelope instead of human output (implies --no-open)").action(
+  async (source2, options) => runExitCodeCommand(() => quickstartCommand(source2, options))
+);
 program.command("serve").description("Start an MCP server exposing wiki tools and resources over stdio").option("--root <dir>", "Project root directory", process.cwd()).action(async (options) => {
   try {
     await startMCPServer({ root: options.root, version });
@@ -6576,44 +9284,21 @@ program.command("serve").description("Start an MCP server exposing wiki tools an
     process.exit(1);
   }
 });
-function applyLanguageOption(lang) {
-  if (lang && lang.trim().length > 0) {
-    process.env.LLMWIKI_OUTPUT_LANG = lang.trim();
-  }
-}
-var PROVIDER_KEY_VARS2 = {
-  anthropic: "ANTHROPIC_API_KEY",
-  openai: "OPENAI_API_KEY",
-  ollama: null,
-  minimax: "MINIMAX_API_KEY",
-  copilot: "GITHUB_TOKEN"
-};
 function requireProvider() {
-  const provider = process.env.LLMWIKI_PROVIDER ?? DEFAULT_PROVIDER;
-  if (provider === "anthropic") {
-    const auth = resolveAnthropicAuthFromEnv();
-    if (!auth.apiKey && !auth.authToken) {
-      console.error(
-        `\x1B[31mError:\x1B[0m Anthropic credentials are required for the "anthropic" provider.
-  Set one of: export ANTHROPIC_API_KEY=<your-key> OR export ANTHROPIC_AUTH_TOKEN=<your-token>`
-      );
-      process.exit(1);
-    }
-    return;
-  }
-  const keyVar = PROVIDER_KEY_VARS2[provider];
-  if (keyVar === void 0) {
-    console.error(
-      `\x1B[31mError:\x1B[0m Unknown provider "${provider}".
-  Supported: ${Object.keys(PROVIDER_KEY_VARS2).join(", ")}`
-    );
+  try {
+    ensureProviderAvailable();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`\x1B[31mError:\x1B[0m ${message}`);
     process.exit(1);
   }
-  if (keyVar && !process.env[keyVar]) {
-    console.error(
-      `\x1B[31mError:\x1B[0m ${keyVar} environment variable is required for the "${provider}" provider.
-  Set it with: export ${keyVar}=<your-key>`
-    );
+}
+async function runExitCodeCommand(work) {
+  try {
+    const code = await work();
+    if (code !== 0) process.exitCode = code;
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
     process.exit(1);
   }
 }