llm-wiki-compiler 0.5.1 → 0.7.0

package/dist/cli.js

@@ -2,17 +2,18 @@
 
 // src/cli.ts
 import "dotenv/config";
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { Command } from "commander";
 
 // src/commands/ingest.ts
-import path7 from "path";
-import { mkdir as mkdir2, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
+import path8 from "path";
+import { readFile as readFile7 } from "fs/promises";
 
 // src/utils/markdown.ts
 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 MIN_LINE_NUMBER = 1;
 var VALID_PROVENANCE_STATES = /* @__PURE__ */ new Set([
@@ -22,7 +23,7 @@ var VALID_PROVENANCE_STATES = /* @__PURE__ */ new Set([
   "ambiguous"
 ]);
 function slugify(title) {
-  return title.toLowerCase().replace(/['']/g, "").replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return title.toLowerCase().replace(/['']/g, "").replace(/[^\p{L}\p{N}\s-]/gu, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function buildFrontmatter(fields) {
   const dumped = yaml.dump(fields, { lineWidth: -1, quotingType: '"' }).trimEnd();
@@ -31,19 +32,27 @@ ${dumped}
 ---`;
 }
 function parseFrontmatter(content) {
+  const { meta, body } = parseFrontmatterStatus(content);
+  return { meta, body };
+}
+function parseFrontmatterStatus(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
   if (!match) {
-    return { meta: {}, body: content };
+    return { meta: {}, body: content, hasFrontmatterBlock: false, malformedFrontmatter: false };
   }
   let meta = {};
+  let malformedFrontmatter = false;
   try {
     const parsed = yaml.load(match[1]);
     if (parsed && typeof parsed === "object") {
       meta = parsed;
+    } else if (parsed !== null && parsed !== void 0) {
+      malformedFrontmatter = true;
     }
   } catch {
+    malformedFrontmatter = true;
   }
-  return { meta, body: match[2] };
+  return { meta, body: match[2], hasFrontmatterBlock: true, malformedFrontmatter };
 }
 async function atomicWrite(filePath, content) {
   await mkdir(path.dirname(filePath), { recursive: true });
@@ -51,6 +60,41 @@ async function atomicWrite(filePath, content) {
   await writeFile(tmpPath, content, "utf-8");
   await rename(tmpPath, filePath);
 }
+function extractClaimCitations(body) {
+  const citations = [];
+  let match;
+  CITATION_MARKER_PATTERN.lastIndex = 0;
+  while ((match = CITATION_MARKER_PATTERN.exec(body)) !== null) {
+    const raw = match[1];
+    const spans = parseCitationEntries(raw);
+    if (spans.length > 0) citations.push({ raw, spans });
+  }
+  return citations;
+}
+function parseCitationEntries(inner) {
+  const spans = [];
+  for (const part of inner.split(",")) {
+    const trimmed = part.trim();
+    if (trimmed.length === 0) continue;
+    const span = parseSpanEntry(trimmed);
+    if (span !== void 0) spans.push(span);
+  }
+  return spans;
+}
+function parseSpanEntry(entry) {
+  const match = SPAN_SUFFIX_PATTERN.exec(entry);
+  if (!match || !match.groups) {
+    return { file: entry };
+  }
+  const { file, colonStart, colonEnd, hashStart, hashEnd } = match.groups;
+  const start = colonStart ?? hashStart;
+  const end = colonEnd ?? hashEnd;
+  if (start === void 0) return { file };
+  const startLine = Number(start);
+  const endLine = end === void 0 ? startLine : Number(end);
+  if (!isValidLineRange(startLine, endLine)) return void 0;
+  return { file, lines: { start: startLine, end: endLine } };
+}
 function isValidLineRange(start, end) {
   return start >= MIN_LINE_NUMBER && end >= start;
 }
@@ -103,16 +147,11 @@ function parseContradictedBy(raw) {
   const refs = raw.map(coerceContradictionEntry).filter((ref) => ref !== null);
   return refs.length > 0 ? refs : void 0;
 }
-function parseInferredParagraphs(raw) {
-  if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) return void 0;
-  return raw;
-}
 function parseProvenanceMetadata(meta) {
   return {
     confidence: parseConfidence(meta.confidence),
     provenanceState: parseProvenanceState(meta.provenanceState),
-    contradictedBy: parseContradictedBy(meta.contradictedBy),
-    inferredParagraphs: parseInferredParagraphs(meta.inferredParagraphs)
+    contradictedBy: parseContradictedBy(meta.contradictedBy)
   };
 }
 function validateWikiPage(content) {
@@ -123,9 +162,16 @@ function validateWikiPage(content) {
   return true;
 }
 
+// src/utils/source-writer.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+import { createHash } from "crypto";
+
 // src/utils/constants.ts
 var MAX_SOURCE_CHARS = 1e5;
 var MIN_SOURCE_CHARS = 50;
+var DEFAULT_PROMPT_BUDGET_CHARS = 2e5;
+var PROMPT_BUDGET_ENV_VAR = "LLMWIKI_PROMPT_BUDGET_CHARS";
 var QUERY_PAGE_LIMIT = 5;
 var COMPILE_CONCURRENCY = 5;
 var RETRY_COUNT = 3;
@@ -136,9 +182,11 @@ var PROVIDER_MODELS = {
   anthropic: "claude-sonnet-4-20250514",
   openai: "gpt-4o",
   ollama: "llama3.1",
-  minimax: "MiniMax-M2.7"
+  minimax: "MiniMax-M2.7",
+  copilot: "gpt-4o"
 };
 var OLLAMA_DEFAULT_HOST = "http://localhost:11434/v1";
+var COPILOT_BASE_URL = "https://api.githubcopilot.com";
 var OPENAI_DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 var OLLAMA_DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
 var SOURCES_DIR = "sources";
@@ -150,6 +198,7 @@ var LOCK_FILE = ".llmwiki/lock";
 var INDEX_FILE = "wiki/index.md";
 var MOC_FILE = "wiki/MOC.md";
 var EMBEDDINGS_FILE = ".llmwiki/embeddings.json";
+var LAST_LINT_FILE = ".llmwiki/last-lint.json";
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".gif", ".webp"]);
 var TRANSCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".vtt", ".srt"]);
 var IMAGE_DESCRIBE_MAX_TOKENS = 2048;
@@ -169,6 +218,42 @@ var EMBEDDING_MODELS = {
   ollama: "nomic-embed-text"
 };
 
+// src/utils/source-writer.ts
+var COLLISION_HASH_LEN = 8;
+function shortHashOfSource(source2) {
+  return createHash("sha256").update(source2).digest("hex").slice(0, COLLISION_HASH_LEN);
+}
+async function resolveCollisionFreeFilename(slug, source2) {
+  const candidate = `${slug}.md`;
+  const candidatePath2 = path2.join(SOURCES_DIR, candidate);
+  let existing;
+  try {
+    existing = await readFile2(candidatePath2, "utf-8");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") return candidate;
+    throw err;
+  }
+  const { meta } = parseFrontmatter(existing);
+  if (typeof meta.source === "string" && meta.source === source2) {
+    return candidate;
+  }
+  return `${slug}-${shortHashOfSource(source2)}.md`;
+}
+async function saveSource(title, document, source2) {
+  const slug = slugify(title);
+  if (!slug) {
+    throw new Error(
+      `Could not derive a filename from title "${title}". The title contains no letter or number characters. Rename the source file to one with at least one letter or digit.`
+    );
+  }
+  await mkdir2(SOURCES_DIR, { recursive: true });
+  const filename = await resolveCollisionFreeFilename(slug, source2);
+  const destPath = path2.join(SOURCES_DIR, filename);
+  await writeFile2(destPath, document, "utf-8");
+  return destPath;
+}
+
 // src/utils/output.ts
 var RESET = "\x1B[0m";
 var BOLD = "\x1B[1m";
@@ -244,13 +329,13 @@ async function ingestWeb(url) {
 }
 
 // src/ingest/file.ts
-import { readFile as readFile2 } from "fs/promises";
-import path3 from "path";
+import { readFile as readFile3 } from "fs/promises";
+import path4 from "path";
 
 // src/ingest/shared.ts
-import path2 from "path";
+import path3 from "path";
 function titleFromFilename(filePath) {
-  const basename = path2.basename(filePath, path2.extname(filePath));
+  const basename = path3.basename(filePath, path3.extname(filePath));
   return basename.replace(/[-_]+/g, " ").trim();
 }
 
@@ -262,20 +347,20 @@ ${text}
 \`\`\``;
 }
 async function ingestFile(filePath) {
-  const ext = path3.extname(filePath).toLowerCase();
+  const ext = path4.extname(filePath).toLowerCase();
   if (!SUPPORTED_EXTENSIONS.has(ext)) {
     throw new Error(
       `Unsupported file type "${ext}". Only .md and .txt files are supported.`
     );
   }
-  const raw = await readFile2(filePath, "utf-8");
+  const raw = await readFile3(filePath, "utf-8");
   const title = titleFromFilename(filePath);
   const content = ext === ".md" ? raw : wrapPlainText(raw);
   return { title, content };
 }
 
 // src/ingest/pdf.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 function resolveTitle(filePath, info2) {
   if (info2 && typeof info2 === "object") {
     const titleField = info2["Title"];
@@ -287,7 +372,7 @@ function resolveTitle(filePath, info2) {
 }
 async function ingestPdf(filePath) {
   const { PDFParse } = await import("pdf-parse");
-  const buffer = await readFile3(filePath);
+  const buffer = await readFile4(filePath);
   const parser = new PDFParse({ data: new Uint8Array(buffer) });
   try {
     const textResult = await parser.getText();
@@ -301,8 +386,8 @@ async function ingestPdf(filePath) {
 }
 
 // src/ingest/image.ts
-import { readFile as readFile4 } from "fs/promises";
-import path5 from "path";
+import { readFile as readFile5 } from "fs/promises";
+import path6 from "path";
 import Anthropic2 from "@anthropic-ai/sdk";
 
 // src/providers/anthropic.ts
@@ -419,7 +504,7 @@ var AnthropicProvider = class {
 // src/utils/claude-settings.ts
 import { readFileSync } from "fs";
 import { homedir } from "os";
-import path4 from "path";
+import path5 from "path";
 var CLAUDE_SETTINGS_PATH_ENV = "LLMWIKI_CLAUDE_SETTINGS_PATH";
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -430,7 +515,7 @@ function normalize(value) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function resolveClaudeSettingsPath(env) {
-  return env[CLAUDE_SETTINGS_PATH_ENV] ?? path4.join(homedir(), ".claude", "settings.json");
+  return env[CLAUDE_SETTINGS_PATH_ENV] ?? path5.join(homedir(), ".claude", "settings.json");
 }
 function readClaudeSettingsFile(settingsPath) {
   try {
@@ -563,9 +648,9 @@ async function ingestImage(filePath) {
       `Image ingest requires the Anthropic provider (vision). Current provider: "${providerName}". Set LLMWIKI_PROVIDER=anthropic and ANTHROPIC_API_KEY to use image ingest.`
     );
   }
-  const ext = path5.extname(filePath).toLowerCase();
+  const ext = path6.extname(filePath).toLowerCase();
   const mimeType = mimeTypeForExtension(ext);
-  const imageBuffer = await readFile4(filePath);
+  const imageBuffer = await readFile5(filePath);
   const imageData = imageBuffer.toString("base64");
   const client = buildClient();
   const model = resolveAnthropicModelFromEnv() ?? PROVIDER_MODELS.anthropic;
@@ -575,8 +660,8 @@ async function ingestImage(filePath) {
 }
 
 // src/ingest/transcript.ts
-import { readFile as readFile5 } from "fs/promises";
-import path6 from "path";
+import { readFile as readFile6 } from "fs/promises";
+import path7 from "path";
 import { YoutubeTranscript } from "youtube-transcript";
 var YOUTUBE_URL_PATTERN = /^https?:\/\/(www\.)?(youtube\.com\/watch|youtu\.be\/)/;
 var SRT_SEQUENCE_PATTERN = /^\d+$/;
@@ -661,8 +746,8 @@ async function ingestTranscript(source2) {
   if (isYoutubeUrl(source2)) {
     return fetchYoutubeTranscript(source2);
   }
-  const ext = path6.extname(source2).toLowerCase();
-  const raw = await readFile5(source2, "utf-8");
+  const ext = path7.extname(source2).toLowerCase();
+  const raw = await readFile6(source2, "utf-8");
   if (ext === ".vtt") return parseVtt(raw, source2);
   if (ext === ".srt") return parseSrt(raw, source2);
   if (ext === ".txt") return parsePlainTranscript(raw, source2);
@@ -701,7 +786,7 @@ function hasSpeakerDialoguePattern(sample) {
   return hasEnoughSpeakers && hasRepeatedSpeaker;
 }
 async function looksLikeTxtTranscript(filePath) {
-  const raw = await readFile6(filePath, "utf-8");
+  const raw = await readFile7(filePath, "utf-8");
   const sample = raw.slice(0, TXT_SNIFF_BYTES);
   if (hasSpeakerDialoguePattern(sample)) return true;
   const timestampMatches = sample.match(new RegExp(TIMESTAMP_PATTERN2.source, "gm"));
@@ -723,124 +808,1571 @@ function enforceCharLimit(content) {
     originalChars: content.length
   };
 }
-function enforceMinContent(content) {
-  const length = content.trim().length;
-  if (length === 0) {
-    throw new Error(
-      "No readable content could be extracted from the source."
-    );
-  }
-  if (length < MIN_SOURCE_CHARS) {
-    status(
-      "!",
-      warn(
-        `Content seems very short (${length} chars, minimum recommended is ${MIN_SOURCE_CHARS}).`
-      )
-    );
+function enforceMinContent(content) {
+  const length = content.trim().length;
+  if (length === 0) {
+    throw new Error(
+      "No readable content could be extracted from the source."
+    );
+  }
+  if (length < MIN_SOURCE_CHARS) {
+    status(
+      "!",
+      warn(
+        `Content seems very short (${length} chars, minimum recommended is ${MIN_SOURCE_CHARS}).`
+      )
+    );
+  }
+}
+async function detectSourceType(source2) {
+  if (!isUrl(source2)) {
+    const ext = path8.extname(source2).toLowerCase();
+    if (ext === ".pdf") return "pdf";
+    if (IMAGE_EXTENSIONS.has(ext)) return "image";
+    if (TRANSCRIPT_EXTENSIONS.has(ext)) return "transcript";
+    if (ext === ".txt") {
+      const isTranscript = await looksLikeTxtTranscript(source2);
+      return isTranscript ? "transcript" : "file";
+    }
+    return "file";
+  }
+  if (isYoutubeUrl(source2)) return "transcript";
+  return "web";
+}
+function buildDocument(title, source2, result, sourceType) {
+  const meta = {
+    title,
+    source: source2,
+    ingestedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (sourceType !== void 0) {
+    meta.sourceType = sourceType;
+  }
+  if (result.truncated) {
+    meta.truncated = true;
+    meta.originalChars = result.originalChars;
+  }
+  const frontmatter = buildFrontmatter(meta);
+  return `${frontmatter}
+
+${result.content}
+`;
+}
+async function fetchContent(source2, sourceType) {
+  switch (sourceType) {
+    case "web":
+      return ingestWeb(source2);
+    case "pdf":
+      return ingestPdf(source2);
+    case "image":
+      return ingestImage(source2);
+    case "transcript":
+      return ingestTranscript(source2);
+    case "file":
+      return ingestFile(source2);
+  }
+}
+async function ingestSource(source2) {
+  const sourceType = await detectSourceType(source2);
+  status("*", info(`Ingesting [${sourceType}]: ${source2}`));
+  const { title, content } = await fetchContent(source2, sourceType);
+  const result = enforceCharLimit(content);
+  enforceMinContent(result.content);
+  const document = buildDocument(title, source2, result, sourceType);
+  const savedPath = await saveSource(title, document, source2);
+  return {
+    filename: path8.basename(savedPath),
+    charCount: result.content.length,
+    truncated: result.truncated,
+    source: source2,
+    sourceType
+  };
+}
+async function ingest(source2) {
+  const result = await ingestSource(source2);
+  const savedPath = path8.join(SOURCES_DIR, result.filename);
+  status(
+    "+",
+    success(`Saved ${bold(result.filename)} \u2192 ${source(savedPath)}`)
+  );
+  status("\u2192", dim("Next: llmwiki compile"));
+}
+
+// src/commands/ingest-session.ts
+import path12 from "path";
+import { readdir, stat } from "fs/promises";
+
+// src/adapters/claude.ts
+import { readFile as readFile8 } from "fs/promises";
+import path9 from "path";
+
+// src/adapters/utils.ts
+var MAX_TITLE_CHARS = 80;
+function truncateTitle(text) {
+  const trimmed = text.trim();
+  return trimmed.length > MAX_TITLE_CHARS ? trimmed.slice(0, MAX_TITLE_CHARS).trimEnd() + "\u2026" : trimmed;
+}
+function resolveSessionTitle(rawTitle, firstUserContent, defaultTitle) {
+  if (rawTitle && rawTitle.trim().length > 0) return truncateTitle(rawTitle);
+  if (firstUserContent) {
+    const firstLine = firstUserContent.split("\n")[0];
+    if (firstLine.trim().length > 0) return truncateTitle(firstLine);
+  }
+  return defaultTitle;
+}
+function parseJsonOrThrow(raw, filePath) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in session file: ${filePath}`);
+  }
+}
+
+// src/adapters/claude.ts
+var CLAUDE_EXTENSION = ".jsonl";
+var CLAUDE_TYPE_MARKERS = /* @__PURE__ */ new Set(["user", "assistant", "system", "tool_use", "tool_result"]);
+function extractText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n");
+}
+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) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function eventToTurn(event) {
+  if (!event.message || !event.message.role) return null;
+  const role = event.message.role;
+  if (role !== "user" && role !== "assistant") return null;
+  const content = extractText(event.message.content);
+  if (content.trim().length === 0) return null;
+  return { role, content, timestamp: event.timestamp };
+}
+var claudeAdapter = {
+  name: "claude",
+  async detect(filePath) {
+    if (path9.extname(filePath).toLowerCase() !== CLAUDE_EXTENSION) return false;
+    const raw = await readFile8(filePath, "utf-8").catch(() => "");
+    const firstLine = raw.split("\n")[0].trim();
+    if (!firstLine.startsWith("{")) return false;
+    try {
+      const obj = JSON.parse(firstLine);
+      return typeof obj.type === "string" && CLAUDE_TYPE_MARKERS.has(obj.type);
+    } catch {
+      return false;
+    }
+  },
+  async parse(filePath) {
+    const raw = await readFile8(filePath, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length === 0) {
+      throw new Error(`Claude session file is empty: ${filePath}`);
+    }
+    const turns = [];
+    const timestamps = [];
+    for (const [index, line] of lines.entries()) {
+      const event = parseLine(line);
+      if (event === null) {
+        throw new Error(
+          `Malformed JSON on line ${index + 1} of Claude session: ${filePath}`
+        );
+      }
+      if (event.timestamp) timestamps.push(event.timestamp);
+      const turn = eventToTurn(event);
+      if (turn) turns.push(turn);
+    }
+    const title = titleFromFirstUserMessage(turns);
+    return {
+      title,
+      adapter: "claude",
+      startedAt: timestamps[0],
+      endedAt: timestamps[timestamps.length - 1],
+      participantIdentity: "Claude Code",
+      turns
+    };
+  }
+};
+
+// src/adapters/codex.ts
+import { readFile as readFile9 } from "fs/promises";
+import path10 from "path";
+var CODEX_EXTENSION = ".json";
+function unixToIso(ts) {
+  return new Date(ts * 1e3).toISOString();
+}
+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
+    });
+  }
+  turns.sort((a, b) => {
+    if (!a.timestamp || !b.timestamp) return 0;
+    return a.timestamp.localeCompare(b.timestamp);
+  });
+  return turns;
+}
+function isCodexExport(value) {
+  return Array.isArray(value) && value.length > 0 && typeof value[0].mapping === "object";
+}
+var codexAdapter = {
+  name: "codex",
+  async detect(filePath) {
+    if (path10.extname(filePath).toLowerCase() !== CODEX_EXTENSION) return false;
+    const raw = await readFile9(filePath, "utf-8").catch(() => "");
+    if (raw.trimStart()[0] !== "[") return false;
+    try {
+      return isCodexExport(JSON.parse(raw));
+    } catch {
+      return false;
+    }
+  },
+  async parse(filePath) {
+    const raw = await readFile9(filePath, "utf-8");
+    const parsed = parseJsonOrThrow(raw, filePath);
+    if (!isCodexExport(parsed)) {
+      throw new Error(
+        `Codex session file does not contain a conversation array: ${filePath}`
+      );
+    }
+    const conv = parsed[0];
+    const turns = extractTurns(conv.mapping ?? {});
+    const firstUser = turns.find((t) => t.role === "user");
+    return {
+      title: resolveSessionTitle(conv.title, firstUser?.content, "Codex Session"),
+      adapter: "codex",
+      startedAt: conv.create_time != null ? unixToIso(conv.create_time) : void 0,
+      endedAt: conv.update_time != null ? unixToIso(conv.update_time) : void 0,
+      participantIdentity: "OpenAI Codex",
+      turns
+    };
+  }
+};
+
+// src/adapters/cursor.ts
+import { readFile as readFile10 } from "fs/promises";
+import path11 from "path";
+var CURSOR_EXTENSION = ".json";
+function isTabsExport(value) {
+  return typeof value === "object" && value !== null && "tabs" in value && Array.isArray(value.tabs);
+}
+function isFlatExport(value) {
+  return typeof value === "object" && value !== null && "messages" in value && Array.isArray(value.messages);
+}
+function extractMessagesAndTitle(data) {
+  if (isTabsExport(data)) {
+    const tab = data.tabs[0];
+    return { messages: tab?.messages ?? [], title: tab?.title };
+  }
+  return { messages: data.messages, title: data.title };
+}
+function toTurns(messages) {
+  const turns = [];
+  for (const msg of messages) {
+    const role = msg.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const content = (msg.content ?? "").trim();
+    if (content.length === 0) continue;
+    turns.push({ role, content, timestamp: msg.timestamp });
+  }
+  return turns;
+}
+var cursorAdapter = {
+  name: "cursor",
+  async detect(filePath) {
+    if (path11.extname(filePath).toLowerCase() !== CURSOR_EXTENSION) return false;
+    const raw = await readFile10(filePath, "utf-8").catch(() => "");
+    if (raw.trimStart()[0] !== "{") return false;
+    try {
+      const parsed = JSON.parse(raw);
+      return isTabsExport(parsed) || isFlatExport(parsed);
+    } catch {
+      return false;
+    }
+  },
+  async parse(filePath) {
+    const raw = await readFile10(filePath, "utf-8");
+    const parsed = parseJsonOrThrow(raw, filePath);
+    if (!isTabsExport(parsed) && !isFlatExport(parsed)) {
+      throw new Error(
+        `Cursor session file does not match a known Cursor export schema: ${filePath}`
+      );
+    }
+    const { messages, title: rawTitle } = extractMessagesAndTitle(parsed);
+    const turns = toTurns(messages);
+    const firstUser = turns.find((t) => t.role === "user");
+    const timestamps = turns.filter((t) => t.timestamp != null).map((t) => t.timestamp);
+    return {
+      title: resolveSessionTitle(rawTitle, firstUser?.content, "Cursor Session"),
+      adapter: "cursor",
+      startedAt: timestamps[0],
+      endedAt: timestamps[timestamps.length - 1],
+      participantIdentity: "Cursor AI",
+      turns
+    };
+  }
+};
+
+// src/adapters/registry.ts
+var ADAPTERS = [claudeAdapter, codexAdapter, cursorAdapter];
+async function detectAdapter(filePath) {
+  for (const adapter of ADAPTERS) {
+    if (await adapter.detect(filePath)) return adapter;
+  }
+  return null;
+}
+async function parseSessionFile(filePath) {
+  const adapter = await detectAdapter(filePath);
+  if (!adapter) {
+    throw new Error(
+      `No session adapter recognised the file: ${filePath}
+Supported formats: ${ADAPTERS.map((a) => a.name).join(", ")}`
+    );
+  }
+  const session = await adapter.parse(filePath);
+  assertSessionHasUsableTurns(session, filePath);
+  return session;
+}
+function assertSessionHasUsableTurns(session, filePath) {
+  const hasUsableTurn = session.turns.some(
+    (t) => (t.role === "user" || t.role === "assistant") && t.content.trim().length > 0
+  );
+  if (!hasUsableTurn) {
+    throw new Error(
+      `${session.adapter} session has no usable turns: ${filePath}
+The file matches the ${session.adapter} export shape, but no user or assistant message with content was found. Re-export the session or delete the file if it is empty.`
+    );
+  }
+}
+function formatSessionAsMarkdown(session) {
+  const lines = [];
+  for (const turn of session.turns) {
+    const label = turn.role === "user" ? "User" : session.participantIdentity ?? "Assistant";
+    const heading = turn.timestamp ? `### ${label} _(${turn.timestamp})_` : `### ${label}`;
+    lines.push(heading);
+    lines.push("");
+    lines.push(turn.content);
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+
+// src/commands/ingest-session.ts
+function buildSessionFrontmatter(session, sourcePath) {
+  const meta = {
+    title: session.title,
+    source: sourcePath,
+    adapter: session.adapter,
+    ingestedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (session.startedAt) meta.sessionStartedAt = session.startedAt;
+  if (session.endedAt) meta.sessionEndedAt = session.endedAt;
+  if (session.participantIdentity) meta.participant = session.participantIdentity;
+  return buildFrontmatter(meta);
+}
+async function saveSessionSource(session, sourcePath) {
+  const frontmatter = buildSessionFrontmatter(session, sourcePath);
+  const body = formatSessionAsMarkdown(session);
+  const document = `${frontmatter}
+
+${body}
+`;
+  return saveSource(session.title, document, sourcePath);
+}
+async function ingestSessionFile(filePath) {
+  status("*", info(`Ingesting session: ${filePath}`));
+  const session = await parseSessionFile(filePath);
+  const savedPath = await saveSessionSource(session, filePath);
+  status(
+    "+",
+    success(
+      `Saved ${bold(path12.basename(savedPath))} [${session.adapter}] \u2192 ${source(savedPath)}`
+    )
+  );
+  return {
+    filename: path12.basename(savedPath),
+    adapter: session.adapter,
+    title: session.title,
+    source: filePath
+  };
+}
+async function listDirectoryFiles(dirPath) {
+  const entries = await readdir(dirPath);
+  const files = [];
+  for (const entry of entries) {
+    const full = path12.join(dirPath, entry);
+    const info2 = await stat(full);
+    if (info2.isFile()) files.push(full);
+  }
+  return files;
+}
+async function ingestDirectory(dirPath) {
+  const files = await listDirectoryFiles(dirPath);
+  if (files.length === 0) {
+    throw new Error(`No files found in directory: ${dirPath}`);
+  }
+  status("*", info(`Scanning ${files.length} file(s) in: ${dirPath}`));
+  let imported = 0;
+  let skipped = 0;
+  for (const file of files) {
+    try {
+      await ingestSessionFile(file);
+      imported++;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      status("!", warn(`Skipped ${path12.basename(file)}: ${message}`));
+      skipped++;
+    }
+  }
+  if (imported === 0) {
+    throw new Error(
+      `No sessions imported from ${dirPath} (${skipped} file(s) skipped). Check that at least one file is in a supported session format.`
+    );
+  }
+  status(
+    "\u2192",
+    dim(`Imported ${imported} session(s), skipped ${skipped}.`)
+  );
+}
+async function ingestSession(targetPath) {
+  const info2 = await stat(targetPath).catch(() => {
+    throw new Error(`Path not found: ${targetPath}`);
+  });
+  if (info2.isDirectory()) {
+    await ingestDirectory(targetPath);
+  } else {
+    await ingestSessionFile(targetPath);
+  }
+  status("\u2192", dim("Next: llmwiki compile"));
+}
+
+// src/commands/view.ts
+import { spawn } from "child_process";
+
+// src/viewer/server.ts
+import http from "http";
+
+// src/linter/cache.ts
+import { mkdir as mkdir3, readFile as readFile11 } from "fs/promises";
+import path13 from "path";
+var LINT_CACHE_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+async function writeLintCache(root, summary) {
+  await mkdir3(path13.join(root, LLMWIKI_DIR), { recursive: true });
+  const entry = {
+    warnings: summary.warnings,
+    errors: summary.errors,
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await atomicWrite(path13.join(root, LAST_LINT_FILE), `${JSON.stringify(entry, null, 2)}
+`);
+}
+async function readLintCache(root) {
+  let raw;
+  try {
+    raw = await readFile11(path13.join(root, LAST_LINT_FILE), "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isValidEntry(parsed)) return null;
+  return { warnings: parsed.warnings, errors: parsed.errors, at: parsed.at };
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isValidEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return isNonNegativeInteger(candidate.warnings) && isNonNegativeInteger(candidate.errors) && typeof candidate.at === "string" && LINT_CACHE_TIMESTAMP_PATTERN.test(candidate.at);
+}
+
+// src/viewer/health.ts
+async function buildHealthResponse(snapshot) {
+  const lint2 = await readLintCache(snapshot.root);
+  return {
+    pendingReviews: snapshot.counts.pendingReviews,
+    sources: snapshot.counts.compiledSources,
+    sourceFiles: snapshot.counts.sourceFiles,
+    concepts: snapshot.counts.concepts,
+    queries: snapshot.counts.queries,
+    lint: lint2
+  };
+}
+
+// src/viewer/shell.ts
+import { readFile as readFile12 } from "fs/promises";
+import path14 from "path";
+var PAGE_INDEX_MARKER = "<!--PAGE_INDEX-->";
+var templateCache = /* @__PURE__ */ new Map();
+async function loadShellTemplate(assetsDir) {
+  const cached = templateCache.get(assetsDir);
+  if (cached !== void 0) return cached;
+  let bytes;
+  try {
+    bytes = await readFile12(path14.join(assetsDir, "index.html"), "utf-8");
+  } catch {
+    bytes = null;
+  }
+  templateCache.set(assetsDir, bytes);
+  return bytes;
+}
+function substitutePageIndex(template, pages) {
+  const embedded = pages.map((page) => ({
+    id: page.id,
+    pageDirectory: page.pageDirectory,
+    slug: page.slug,
+    title: page.title,
+    kind: typeof page.frontmatter.kind === "string" && page.frontmatter.kind.length > 0 ? page.frontmatter.kind : "concept"
+  }));
+  const json = JSON.stringify({ pages: embedded }).replace(/</g, "\\u003c");
+  const block = `<script type="application/json" id="page-index">${json}</script>`;
+  return template.replace(PAGE_INDEX_MARKER, block);
+}
+
+// src/viewer/static-assets.ts
+import { readFile as readFile13, realpath } from "fs/promises";
+import path16 from "path";
+import { fileURLToPath } from "url";
+
+// src/viewer/path-safety.ts
+import path15 from "path";
+var PathSafetyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PathSafetyError";
+  }
+};
+function assertSafeSlug(decodedSlug) {
+  if (typeof decodedSlug !== "string") {
+    throw new PathSafetyError("slug must be a string");
+  }
+  if (decodedSlug.length === 0) {
+    throw new PathSafetyError("slug must not be empty");
+  }
+  if (decodedSlug === "." || decodedSlug === "..") {
+    throw new PathSafetyError(`slug must not be "${decodedSlug}"`);
+  }
+  if (decodedSlug.includes("/") || decodedSlug.includes("\\")) {
+    throw new PathSafetyError("slug must not contain path separators");
+  }
+  if (decodedSlug.includes("\0")) {
+    throw new PathSafetyError("slug must not contain NUL bytes");
+  }
+  if (path15.sep !== "/" && decodedSlug.includes(path15.sep)) {
+    throw new PathSafetyError(`slug must not contain platform separator "${path15.sep}"`);
+  }
+}
+
+// src/viewer/static-assets.ts
+var ASSETS_DIR = path16.join(
+  path16.dirname(fileURLToPath(import.meta.url)),
+  "viewer/assets"
+);
+var ASSET_CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png"
+};
+async function handleAsset(res, pathname) {
+  const segments = decodeAssetSegments(pathname);
+  if (!segments) {
+    writeAssetError(res, 400, "bad_asset_path", "Bad asset path.");
+    return;
+  }
+  if (segments.length === 0) {
+    writeAssetError(res, 404, "asset_not_found", "Asset not found.");
+    return;
+  }
+  const contentType = ASSET_CONTENT_TYPES[path16.extname(segments[segments.length - 1]).toLowerCase()];
+  if (!contentType) {
+    writeAssetError(res, 404, "asset_not_found", "Asset not found.");
+    return;
+  }
+  const resolved = await resolveAssetPath(segments);
+  if (!resolved) {
+    writeAssetError(res, 404, "asset_not_found", "Asset not found.");
+    return;
+  }
+  try {
+    const body = await readFile13(resolved);
+    res.statusCode = 200;
+    res.setHeader("Content-Type", contentType);
+    res.end(body);
+  } catch {
+    writeAssetError(res, 404, "asset_not_found", "Asset not found.");
+  }
+}
+function decodeAssetSegments(pathname) {
+  const trimmed = pathname.replace(/^\/assets\//, "");
+  if (trimmed.length === 0) return [];
+  const decoded = [];
+  for (const raw of trimmed.split("/")) {
+    let segment;
+    try {
+      segment = decodeURIComponent(raw);
+    } catch {
+      return null;
+    }
+    try {
+      assertSafeSlug(segment);
+    } catch (err) {
+      if (err instanceof PathSafetyError) return null;
+      throw err;
+    }
+    decoded.push(segment);
+  }
+  return decoded;
+}
+async function resolveAssetPath(segments) {
+  const candidate = path16.join(ASSETS_DIR, ...segments);
+  let resolved;
+  try {
+    resolved = await realpath(candidate);
+  } catch {
+    return null;
+  }
+  const baseReal = await realpath(ASSETS_DIR).catch(() => ASSETS_DIR);
+  if (resolved === baseReal) return resolved;
+  const prefix = baseReal.endsWith(path16.sep) ? baseReal : baseReal + path16.sep;
+  return resolved.startsWith(prefix) ? resolved : null;
+}
+function writeAssetError(res, status2, code, message) {
+  res.statusCode = status2;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.end(JSON.stringify({ error: { code, message } }));
+}
+
+// src/viewer/render.ts
+import MarkdownIt from "markdown-it";
+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;
+function extractWikilinkSlugs(body) {
+  const slugs = /* @__PURE__ */ new Set();
+  WIKILINK_RE.lastIndex = 0;
+  let match;
+  while ((match = WIKILINK_RE.exec(body)) !== null) {
+    slugs.add(slugify(match[1].trim()));
+  }
+  return [...slugs];
+}
+async function safeRealpath(p) {
+  try {
+    return await realpath2(p);
+  } catch {
+    return null;
+  }
+}
+function isInsideDir(child, dir) {
+  if (child === dir) return true;
+  const prefix = dir.endsWith(path17.sep) ? dir : dir + path17.sep;
+  return child.startsWith(prefix);
+}
+async function parsePageFile(filePath, slug, pageDirectory) {
+  let raw;
+  try {
+    raw = await readFile14(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const { meta, body, hasFrontmatterBlock, malformedFrontmatter } = parseFrontmatterStatus(raw);
+  const title = typeof meta.title === "string" && meta.title.length > 0 ? meta.title : void 0;
+  return {
+    slug,
+    pageDirectory,
+    filePath,
+    title,
+    frontmatter: meta,
+    body,
+    parseStatus: {
+      hasFrontmatterBlock,
+      malformedFrontmatter,
+      hasTitle: title !== void 0,
+      orphaned: meta.orphaned === true
+    }
+  };
+}
+async function collectFromDir(canonicalRoot, pageDirectory, subdir) {
+  const expectedDir = path17.join(canonicalRoot, subdir);
+  const realDir = await safeRealpath(expectedDir);
+  if (realDir !== expectedDir) return [];
+  let files;
+  try {
+    files = await readdir2(realDir);
+  } catch {
+    return [];
+  }
+  const pages = [];
+  for (const file of files.filter((f) => f.endsWith(".md"))) {
+    const candidate = path17.join(realDir, file);
+    const resolved = await safeRealpath(candidate);
+    if (!resolved || !isInsideDir(resolved, realDir)) continue;
+    const slug = file.replace(/\.md$/, "");
+    const page = await parsePageFile(resolved, slug, pageDirectory);
+    if (page) pages.push(page);
+  }
+  return pages;
+}
+async function collectRawWikiPages(root) {
+  const canonicalRoot = await safeRealpath(root);
+  if (!canonicalRoot) return [];
+  const [concepts, queries] = await Promise.all([
+    collectFromDir(canonicalRoot, "concepts", CONCEPTS_DIR),
+    collectFromDir(canonicalRoot, "queries", QUERIES_DIR)
+  ]);
+  return [...concepts, ...queries];
+}
+
+// src/viewer/collect.ts
+async function collectViewerPages(root) {
+  const raw = await collectRawWikiPages(root);
+  return decoratePages(raw);
+}
+function resolveBareSlug(slug, pages) {
+  if (slug.length === 0) return null;
+  const concept = pages.find((p) => p.pageDirectory === "concepts" && p.slug === slug);
+  if (concept) return concept.id;
+  const query = pages.find((p) => p.pageDirectory === "queries" && p.slug === slug);
+  if (query) return query.id;
+  return null;
+}
+function resolveBareSlugList(targets, pages) {
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const target of targets) {
+    const resolved = resolveBareSlug(target, pages);
+    if (resolved && !seen.has(resolved)) {
+      seen.add(resolved);
+      ordered.push(resolved);
+    }
+  }
+  return ordered;
+}
+function decoratePages(raw) {
+  const shells = raw.map(buildPageShell);
+  for (const page of shells) {
+    const targets = extractWikilinkSlugs(page.body);
+    page.outgoingLinks = resolveBareSlugList(targets, shells);
+  }
+  return shells;
+}
+function buildPageShell(page) {
+  const id = `${page.pageDirectory}/${page.slug}`;
+  return {
+    id,
+    slug: page.slug,
+    pageDirectory: page.pageDirectory,
+    title: page.title ?? page.slug,
+    filePath: page.filePath,
+    frontmatter: page.frontmatter,
+    body: page.body,
+    outgoingLinks: [],
+    citations: extractClaimCitations(page.body),
+    warnings: warningsFromParseStatus(page)
+  };
+}
+function warningsFromParseStatus(page) {
+  const warnings = [];
+  if (!page.parseStatus.hasFrontmatterBlock) {
+    warnings.push({
+      code: "missing_frontmatter",
+      message: `Page "${page.slug}" has no frontmatter block.`
+    });
+  } else if (page.parseStatus.malformedFrontmatter) {
+    warnings.push({
+      code: "malformed_frontmatter",
+      message: `Page "${page.slug}" has malformed YAML frontmatter.`
+    });
+  }
+  if (!page.parseStatus.hasTitle) {
+    warnings.push({
+      code: "missing_title",
+      message: `Page "${page.slug}" has no frontmatter title; displaying slug.`
+    });
+  }
+  return warnings;
+}
+
+// src/viewer/markdown-it-helpers.ts
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function currentLinkLevel(state) {
+  const lifted = state;
+  return typeof lifted.linkLevel === "number" ? lifted.linkLevel : 0;
+}
+function shouldDeferInlineRule(state, silent) {
+  if (currentLinkLevel(state) > 0) return true;
+  if (silent) return true;
+  return false;
+}
+
+// src/viewer/wikilink-rule.ts
+var OPEN = "[";
+var CHAR_OPEN_BRACKET = 91;
+function registerWikilink(md, context) {
+  md.inline.ruler.after("link", "wikilink", buildParser(context));
+  md.renderer.rules.wikilink = (tokens, idx) => renderWikilinkToken(tokens[idx]);
+}
+function buildParser(context) {
+  return function parseWikilink(state, silent) {
+    if (state.src.charCodeAt(state.pos) !== CHAR_OPEN_BRACKET) return false;
+    if (state.src.charCodeAt(state.pos + 1) !== CHAR_OPEN_BRACKET) return false;
+    if (shouldDeferInlineRule(state, silent)) return false;
+    const closeAt = state.src.indexOf("]]", state.pos + 2);
+    if (closeAt < 0) return false;
+    const inner = state.src.slice(state.pos + 2, closeAt);
+    if (inner.includes("\n") || inner.includes(OPEN)) return false;
+    const { rawTarget, display } = splitTargetAndAlias(inner);
+    const slug = slugify(rawTarget.trim());
+    const resolved = resolveBareSlug(slug, context.pages);
+    pushWikilinkToken(state, resolved, slug, display);
+    state.pos = closeAt + 2;
+    return true;
+  };
+}
+function splitTargetAndAlias(inner) {
+  const pipe = inner.indexOf("|");
+  if (pipe < 0) return { rawTarget: inner, display: inner.trim() };
+  return {
+    rawTarget: inner.slice(0, pipe),
+    display: inner.slice(pipe + 1).trim() || inner.slice(0, pipe).trim()
+  };
+}
+function pushWikilinkToken(state, resolved, slug, display) {
+  const token = state.push("wikilink", "", 0);
+  token.meta = { resolved, slug, display };
+}
+function renderWikilinkToken(token) {
+  const meta = token.meta;
+  const display = escapeHtml(meta.display || meta.slug);
+  if (!meta.resolved) {
+    return `<span data-missing="true">[[${display}]]</span>`;
+  }
+  const href = `#/${encodeUriSegment(meta.resolved)}`;
+  return `<a class="wikilink" data-page-id="${escapeHtml(meta.resolved)}" href="${escapeHtml(href)}">${display}</a>`;
+}
+function encodeUriSegment(id) {
+  const [directory, slug] = id.split("/");
+  return `${encodeURIComponent(directory)}/${encodeURIComponent(slug)}`;
+}
+
+// src/viewer/citation-rule.ts
+import path18 from "path";
+import { pathToFileURL } from "url";
+var CHAR_CARET = 94;
+var CHAR_OPEN_BRACKET2 = 91;
+function registerCitation(md, context) {
+  md.inline.ruler.after("link", "citation", buildParser2(context));
+  md.renderer.rules.citation = (tokens, idx) => renderCitationToken(tokens[idx]);
+}
+function buildParser2(context) {
+  return function parseCitation(state, silent) {
+    if (state.src.charCodeAt(state.pos) !== CHAR_CARET) return false;
+    if (state.src.charCodeAt(state.pos + 1) !== CHAR_OPEN_BRACKET2) return false;
+    if (shouldDeferInlineRule(state, silent)) return false;
+    const closeAt = state.src.indexOf("]", state.pos + 2);
+    if (closeAt < 0) return false;
+    const inner = state.src.slice(state.pos + 2, closeAt);
+    if (inner.includes("\n")) return false;
+    const citations = extractClaimCitations(`^[${inner}]`);
+    pushChipTokens(state, citations, context);
+    state.pos = closeAt + 1;
+    return true;
+  };
+}
+function pushChipTokens(state, citations, context) {
+  for (const citation of citations) {
+    for (const span of citation.spans) {
+      const token = state.push("citation", "", 0);
+      token.meta = buildChipMeta(span, context);
+    }
+  }
+}
+function buildChipMeta(span, context) {
+  const meta = {
+    file: span.file,
+    lineStart: span.lines?.start,
+    lineEnd: span.lines?.end,
+    resolved: context.sourceFiles.has(span.file)
+  };
+  if (context.isLoopback && meta.resolved && isBareFilename(span.file)) {
+    const absolutePath = path18.join(context.root, "sources", span.file);
+    meta.absolutePath = absolutePath;
+    meta.editorHref = buildEditorHref(absolutePath, meta.lineStart);
+  }
+  return meta;
+}
+function buildEditorHref(absolutePath, lineStart) {
+  const encodedPath = pathToFileURL(absolutePath).pathname;
+  if (lineStart === void 0) return `vscode://file${encodedPath}`;
+  return `vscode://file${encodedPath}:${lineStart}`;
+}
+function isBareFilename(file) {
+  if (file.length === 0) return false;
+  if (file.includes("/") || file.includes("\\") || file.includes("\0")) return false;
+  if (file === "." || file === "..") return false;
+  return true;
+}
+function renderCitationToken(token) {
+  const meta = token.meta;
+  const label = formatChipLabel(meta);
+  const attrs = chipAttributes(meta);
+  return `<span ${attrs}>${escapeHtml(label)}</span>`;
+}
+function chipAttributes(meta) {
+  const parts = [
+    `class="citation-chip"`,
+    `data-file="${escapeHtml(meta.file)}"`,
+    `data-resolved="${meta.resolved ? "true" : "false"}"`
+  ];
+  if (meta.lineStart !== void 0) {
+    parts.push(`data-line-start="${meta.lineStart}"`);
+  }
+  if (meta.lineEnd !== void 0) {
+    parts.push(`data-line-end="${meta.lineEnd}"`);
+  }
+  if (meta.absolutePath !== void 0) {
+    parts.push(`data-absolute-path="${escapeHtml(meta.absolutePath)}"`);
+  }
+  if (meta.editorHref !== void 0) {
+    parts.push(`data-editor-href="${escapeHtml(meta.editorHref)}"`);
+  }
+  return parts.join(" ");
+}
+function formatChipLabel(meta) {
+  if (meta.lineStart === void 0) return meta.file;
+  if (meta.lineEnd === void 0 || meta.lineEnd === meta.lineStart) {
+    return `${meta.file}:${meta.lineStart}`;
+  }
+  return `${meta.file}:${meta.lineStart}-${meta.lineEnd}`;
+}
+
+// src/viewer/render.ts
+function renderPageHtml(body, snapshot, options) {
+  const md = buildMarkdownIt(snapshot, options);
+  const rendered = md.render(body);
+  const html = sanitizeHtml(rendered, buildSanitizerPolicy(options));
+  return { html };
+}
+function buildMarkdownIt(snapshot, options) {
+  const md = new MarkdownIt({
+    html: false,
+    linkify: false,
+    breaks: false
+  });
+  registerWikilink(md, { pages: snapshot.pages });
+  registerCitation(md, {
+    root: snapshot.root,
+    sourceFiles: new Set(snapshot.sourceFilenames),
+    isLoopback: options.isLoopback
+  });
+  return md;
+}
+function buildSanitizerPolicy(options) {
+  const allowedSchemes = ["http", "https", "mailto"];
+  const allowedSchemesAppliedToAttributes = ["href", "src", "cite"];
+  return {
+    allowedTags: [
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "p",
+      "br",
+      "hr",
+      "ul",
+      "ol",
+      "li",
+      "blockquote",
+      "strong",
+      "em",
+      "b",
+      "i",
+      "s",
+      "u",
+      "code",
+      "pre",
+      "table",
+      "thead",
+      "tbody",
+      "tfoot",
+      "tr",
+      "th",
+      "td",
+      "a",
+      "img",
+      "span",
+      "div"
+    ],
+    disallowedTagsMode: "discard",
+    allowedAttributes: {
+      a: ["href", "title", "class", "id", "data-*", "aria-*"],
+      img: ["src", "alt", "title", "class", "id"],
+      span: ["class", "id", "data-*", "aria-*"],
+      div: ["class", "id", "data-*", "aria-*"],
+      th: ["scope", "colspan", "rowspan", "class", "id"],
+      td: ["colspan", "rowspan", "class", "id"],
+      table: ["class", "id"],
+      code: ["class"],
+      "*": ["class", "id"]
+    },
+    allowedSchemes,
+    allowedSchemesByTag: {
+      a: buildAnchorSchemes(),
+      img: ["http", "https", "data"]
+    },
+    allowedSchemesAppliedToAttributes,
+    allowProtocolRelative: false,
+    // `allowedAttributes` above whitelists `class` everywhere via `*`,
+    // so no further class-name allowlist is needed; leaving
+    // `allowedClasses` unset lets every class value through.
+    allowedStyles: {},
+    allowedIframeHostnames: [],
+    transformTags: {
+      a: filterAnchorHref(),
+      img: filterImgSrc,
+      span: filterSpanForLanBind(options)
+    }
+    // sanitize-html's URL filter does not enforce hash-only links by
+    // default; the anchor transform above whitelists `#/…` explicitly.
+  };
+}
+function filterSpanForLanBind(options) {
+  return function transformSpan(tagName, attribs) {
+    if (options.isLoopback) return { tagName, attribs };
+    if (!("data-absolute-path" in attribs) && !("data-editor-href" in attribs)) {
+      return { tagName, attribs };
+    }
+    const stripped = {};
+    for (const [key, value] of Object.entries(attribs)) {
+      if (key === "data-absolute-path" || key === "data-editor-href") continue;
+      stripped[key] = value;
+    }
+    return { tagName, attribs: stripped };
+  };
+}
+function buildAnchorSchemes() {
+  return ["http", "https", "mailto"];
+}
+function filterAnchorHref() {
+  return function transformAnchor(tagName, attribs) {
+    const href = attribs.href;
+    if (typeof href !== "string" || href.length === 0) return { tagName, attribs };
+    if (isAllowedAnchorHref(href)) return { tagName, attribs };
+    const stripped = { ...attribs };
+    delete stripped.href;
+    return { tagName, attribs: stripped };
+  };
+}
+function filterImgSrc(tagName, attribs) {
+  const src = attribs.src;
+  if (typeof src !== "string" || src.length === 0) return { tagName, attribs };
+  if (isAllowedImgSrc(src)) return { tagName, attribs };
+  const stripped = { ...attribs };
+  delete stripped.src;
+  return { tagName, attribs: stripped };
+}
+function isAllowedAnchorHref(href) {
+  if (href.startsWith("#")) return true;
+  if (href.startsWith("http://") || href.startsWith("https://")) return true;
+  if (href.startsWith("mailto:")) return true;
+  return false;
+}
+function isAllowedImgSrc(src) {
+  if (src.startsWith("http://") || src.startsWith("https://")) return true;
+  if (src.startsWith("data:image/")) return true;
+  return false;
+}
+
+// src/viewer/search.ts
+var MAX_QUERY_LENGTH = 200;
+var MAX_RESULTS = 50;
+var SNIPPET_RADIUS = 60;
+var SNIPPET_ELLIPSIS = "\u2026";
+function searchPages(snapshot, rawQuery) {
+  const tokens = tokenizeQuery(rawQuery);
+  if (tokens.length === 0) return { results: [] };
+  const matches = collectMatches(snapshot.pages, tokens);
+  matches.sort(compareResults);
+  return { results: matches.slice(0, MAX_RESULTS) };
+}
+function tokenizeQuery(rawQuery) {
+  if (typeof rawQuery !== "string") return [];
+  const trimmed = rawQuery.trim();
+  if (trimmed.length === 0) return [];
+  const capped = trimmed.slice(0, MAX_QUERY_LENGTH).toLowerCase();
+  return capped.split(/\s+/).filter((t) => t.length > 0);
+}
+function collectMatches(pages, tokens) {
+  const matches = [];
+  for (const page of pages) {
+    const result = matchPage(page, tokens);
+    if (result) matches.push(result);
+  }
+  return matches;
+}
+function matchPage(page, tokens) {
+  const titleLower = page.title.toLowerCase();
+  const bodyLower = page.body.toLowerCase();
+  for (const token of tokens) {
+    if (!titleLower.includes(token) && !bodyLower.includes(token)) return null;
+  }
+  const allInTitle = tokens.every((t) => titleLower.includes(t));
+  if (allInTitle) return rowFromPage(page, page.title, "title");
+  const snippet = buildBodySnippet(page.body, bodyLower, tokens);
+  return rowFromPage(page, snippet, "body");
+}
+function rowFromPage(page, snippet, matchedIn) {
+  return {
+    id: page.id,
+    pageDirectory: page.pageDirectory,
+    title: page.title,
+    snippet,
+    matchedIn
+  };
+}
+function buildBodySnippet(body, bodyLower, tokens) {
+  const matchPos = earliestTokenPosition(bodyLower, tokens);
+  const start = Math.max(0, matchPos - SNIPPET_RADIUS);
+  const end = Math.min(body.length, matchPos + SNIPPET_RADIUS);
+  const cleaned = stripInlineMarkdownNoise(body.slice(start, end)).replace(/\s+/g, " ").trim();
+  const prefix = start > 0 ? SNIPPET_ELLIPSIS : "";
+  const suffix = end < body.length ? SNIPPET_ELLIPSIS : "";
+  return `${prefix}${cleaned}${suffix}`;
+}
+function stripInlineMarkdownNoise(text) {
+  return text.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/\[\[([^\]|\n]+)\|([^\]\n]+)\]\]/g, "$2").replace(/\[\[([^\]\n]+)\]\]/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/(?<!\w)\*([^*\n]+)\*(?!\w)/g, "$1").replace(/(?<!\w)_([^_\n]+)_(?!\w)/g, "$1").replace(/`([^`\n]+)`/g, "$1").replace(/~~([^~\n]+)~~/g, "$1");
+}
+function earliestTokenPosition(bodyLower, tokens) {
+  let earliest = bodyLower.length;
+  for (const token of tokens) {
+    const idx = bodyLower.indexOf(token);
+    if (idx >= 0 && idx < earliest) earliest = idx;
+  }
+  return earliest;
+}
+function compareResults(a, b) {
+  if (a.matchedIn !== b.matchedIn) {
+    return a.matchedIn === "title" ? -1 : 1;
+  }
+  return a.title.localeCompare(b.title);
+}
+
+// src/viewer/server.ts
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "::1"]);
+var CONTENT_SECURITY_POLICY = "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; font-src 'self'; connect-src 'self'; frame-ancestors 'none'; base-uri 'none'; object-src 'none'; form-action 'none'";
+async function startViewerServer(snapshot, config) {
+  const boundConfig = { ...config };
+  const server = http.createServer((req, res) => {
+    handleRequest(req, res, snapshot, boundConfig).catch((err) => {
+      void err;
+      if (!res.headersSent) {
+        writeJsonError(res, 500, "internal_error", "Unexpected server error.");
+      }
+    });
+  });
+  await new Promise((resolve, reject) => {
+    const onError = (err) => {
+      server.off("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(config.port, config.host);
+  });
+  const address = server.address();
+  if (!address) throw new Error("server bound but address is null");
+  boundConfig.port = address.port;
+  return {
+    host: config.host,
+    port: address.port,
+    close: () => new Promise((resolve) => server.close(() => resolve()))
+  };
+}
+async function handleRequest(req, res, snapshot, config) {
+  applySecurityHeaders(res);
+  if (!validateOriginHeaders(req, config)) {
+    writeJsonError(res, 403, "forbidden", "rejected by origin policy");
+    return;
+  }
+  const url = new URL(req.url ?? "/", buildOriginBase(config));
+  if (!isRouteRegistered(req.method, url.pathname)) {
+    writeJsonError(res, 404, "not_found", `${req.method ?? "?"} ${url.pathname}`);
+    return;
+  }
+  await routeRegistered(req, res, url, snapshot, LOOPBACK_HOSTS.has(config.host));
+}
+async function routeRegistered(req, res, parsedUrl, snapshot, isLoopback) {
+  if (parsedUrl.pathname === "/") return handleShell(res, snapshot);
+  if (parsedUrl.pathname.startsWith("/assets/")) return handleAsset(res, parsedUrl.pathname);
+  if (parsedUrl.pathname === "/api/pages") return handleApiPages(res, snapshot);
+  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.startsWith("/api/page/")) {
+    return handleApiPage(res, parsedUrl.pathname, snapshot, isLoopback);
+  }
+  throw new Error(`route registration drift: no handler for ${parsedUrl.pathname}`);
+}
+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;
+}
+function applySecurityHeaders(res) {
+  res.setHeader("Content-Security-Policy", CONTENT_SECURITY_POLICY);
+  res.setHeader("Cross-Origin-Resource-Policy", "same-origin");
+  res.setHeader("X-Content-Type-Options", "nosniff");
+  res.setHeader("Referrer-Policy", "no-referrer");
+}
+function validateOriginHeaders(req, config) {
+  const host = req.headers.host;
+  if (!host || !isAcceptableHost(host, config)) return false;
+  const origin = req.headers.origin;
+  if (typeof origin === "string" && origin.length > 0) {
+    if (!isSameOrigin(origin, config)) return false;
+  }
+  const fetchSite = req.headers["sec-fetch-site"];
+  if (fetchSite === "cross-site") return false;
+  return true;
+}
+function isAcceptableHost(hostHeader, config) {
+  for (const acceptable of buildAcceptableHostHeaders(config)) {
+    if (hostHeader === acceptable) return true;
+  }
+  return false;
+}
+function buildAcceptableHostHeaders(config) {
+  const formattedBind = formatHostHeader(config.host, config.port);
+  const accepted = [formattedBind];
+  if (config.host === "127.0.0.1" || config.host === "::1") {
+    accepted.push(`localhost:${config.port}`);
+  }
+  return accepted;
+}
+function isSameOrigin(origin, config) {
+  try {
+    const parsed = new URL(origin);
+    const expectedHostname = normalizeHostnameForOrigin(config.host);
+    const originHostname = normalizeHostnameForOrigin(parsed.hostname);
+    return originHostname === expectedHostname && Number(parsed.port) === config.port;
+  } catch {
+    return false;
+  }
+}
+function formatHostHeader(host, port) {
+  if (host.includes(":")) return `[${host}]:${port}`;
+  return `${host}:${port}`;
+}
+function buildOriginBase(config) {
+  if (config.host.includes(":")) return `http://[${config.host}]:${config.port}`;
+  return `http://${config.host}:${config.port}`;
+}
+function normalizeHostnameForOrigin(host) {
+  let h = host.toLowerCase();
+  if (h.startsWith("[") && h.endsWith("]")) h = h.slice(1, -1);
+  return h;
+}
+async function handleShell(res, snapshot) {
+  const template = await loadShellTemplate(ASSETS_DIR);
+  if (template === null) {
+    writeJsonError(res, 500, "shell_missing", "Viewer shell template not found on disk.");
+    return;
+  }
+  const body = substitutePageIndex(template, snapshot.pages);
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "text/html; charset=utf-8");
+  res.end(body);
+}
+function handleApiPages(res, snapshot) {
+  writeJson(res, 200, {
+    project: snapshot.project,
+    counts: {
+      concepts: snapshot.counts.concepts,
+      queries: snapshot.counts.queries,
+      sourceFiles: snapshot.counts.sourceFiles,
+      pendingReviews: snapshot.counts.pendingReviews
+    },
+    index: { available: snapshot.index.available, href: snapshot.index.href },
+    recentPages: snapshot.recentPages,
+    pages: snapshot.pages.map(pageListRow),
+    updatedAt: snapshot.generatedAt
+  });
+}
+function pageListRow(page) {
+  return {
+    id: page.id,
+    pageDirectory: page.pageDirectory,
+    slug: page.slug,
+    title: page.title,
+    kind: typeof page.frontmatter.kind === "string" ? page.frontmatter.kind : "concept",
+    summary: typeof page.frontmatter.summary === "string" ? page.frontmatter.summary : "",
+    updatedAt: typeof page.frontmatter.updatedAt === "string" ? page.frontmatter.updatedAt : "",
+    warnings: page.warnings
+  };
+}
+function handleApiIndex(res, snapshot, isLoopback) {
+  if (!snapshot.index.available) {
+    writeJsonError(res, 404, "index_unavailable", "wiki/index.md is not present.");
+    return;
+  }
+  const rendered = tryRenderBody(snapshot.index.body, snapshot, isLoopback);
+  if (rendered === null) {
+    writeRenderFailed(res);
+    return;
+  }
+  writeJson(res, 200, {
+    html: rendered.html,
+    outgoingLinks: snapshot.index.outgoingLinks,
+    generatedAt: snapshot.generatedAt
+  });
+}
+async function handleApiHealth(res, snapshot) {
+  const health = await buildHealthResponse(snapshot);
+  writeJson(res, 200, health);
+}
+function handleApiSearch(res, parsedUrl, snapshot) {
+  const query = parsedUrl.searchParams.get("q") ?? "";
+  writeJson(res, 200, searchPages(snapshot, query));
+}
+function handleApiPage(res, pathname, snapshot, isLoopback) {
+  const segments = pathname.replace(/^\/api\/page\//, "").split("/");
+  if (segments.length !== 2) {
+    writeJsonError(res, 400, "bad_request", "Expected /api/page/:directory/:slug");
+    return;
+  }
+  const [directorySegment, encodedSlug] = segments;
+  const decodedSlug = safeDecodeSlug(directorySegment, encodedSlug);
+  if (!decodedSlug) {
+    writeJsonError(res, 400, "bad_request", "Invalid directory or slug.");
+    return;
+  }
+  const page = snapshot.pages.find(
+    (p) => p.pageDirectory === decodedSlug.directory && p.slug === decodedSlug.slug
+  );
+  if (!page) {
+    writeJsonError(res, 404, "page_not_found", `${decodedSlug.directory}/${decodedSlug.slug}`);
+    return;
+  }
+  const rendered = tryRenderBody(page.body, snapshot, isLoopback);
+  if (rendered === null) {
+    writeRenderFailed(res);
+    return;
+  }
+  writeJson(res, 200, pagePayload(page, snapshot, rendered.html));
+}
+function safeDecodeSlug(directorySegment, encodedSlug) {
+  if (directorySegment !== "concepts" && directorySegment !== "queries") return null;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(encodedSlug);
+  } catch {
+    return null;
+  }
+  try {
+    assertSafeSlug(decoded);
+  } catch (err) {
+    if (err instanceof PathSafetyError) return null;
+    throw err;
+  }
+  return { directory: directorySegment, slug: decoded };
+}
+function pagePayload(page, snapshot, renderedHtml) {
+  return {
+    id: page.id,
+    title: page.title,
+    pageDirectory: page.pageDirectory,
+    slug: page.slug,
+    html: renderedHtml,
+    citations: page.citations,
+    outgoingLinks: page.outgoingLinks,
+    frontmatter: page.frontmatter,
+    warnings: page.warnings,
+    updatedAt: typeof page.frontmatter.updatedAt === "string" ? page.frontmatter.updatedAt : "",
+    createdAt: typeof page.frontmatter.createdAt === "string" ? page.frontmatter.createdAt : "",
+    generatedAt: snapshot.generatedAt
+  };
+}
+function tryRenderBody(body, snapshot, isLoopback) {
+  try {
+    return renderPageHtml(body, snapshot, { isLoopback });
+  } catch {
+    return null;
+  }
+}
+function writeRenderFailed(res) {
+  writeJsonError(res, 500, "render_failed", "Could not render page.");
+}
+function writeJson(res, status2, body) {
+  res.statusCode = status2;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(body));
+}
+function writeJsonError(res, status2, code, message) {
+  writeJson(res, status2, { error: { code, message } });
+}
+
+// src/viewer/snapshot.ts
+import { readdir as readdir4, readFile as readFile16, realpath as realpath3 } from "fs/promises";
+import path21 from "path";
+
+// src/compiler/candidates.ts
+import { readdir as readdir3, rename as rename2, unlink, writeFile as writeFile3, mkdir as mkdir4 } from "fs/promises";
+import { existsSync } from "fs";
+import path19 from "path";
+import { randomBytes } from "crypto";
+var ID_SUFFIX_BYTES = 4;
+var CANDIDATE_EXT = ".json";
+function buildCandidateId(slug) {
+  const suffix = randomBytes(ID_SUFFIX_BYTES).toString("hex");
+  return `${slug}-${suffix}`;
+}
+function candidatePath(root, id) {
+  return path19.join(root, CANDIDATES_DIR, `${id}${CANDIDATE_EXT}`);
+}
+function archivePath(root, id) {
+  return path19.join(root, CANDIDATES_ARCHIVE_DIR, `${id}${CANDIDATE_EXT}`);
+}
+async function writeCandidate(root, draft) {
+  const candidate = {
+    id: buildCandidateId(draft.slug),
+    title: draft.title,
+    slug: draft.slug,
+    summary: draft.summary,
+    sources: draft.sources,
+    body: draft.body,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...draft.sourceStates ? { sourceStates: draft.sourceStates } : {},
+    ...draft.schemaViolations ? { schemaViolations: draft.schemaViolations } : {},
+    ...draft.provenanceViolations ? { provenanceViolations: draft.provenanceViolations } : {}
+  };
+  await atomicWrite(candidatePath(root, candidate.id), JSON.stringify(candidate, null, 2));
+  return candidate;
+}
+function failWithError(message) {
+  status("!", error(message));
+  process.exitCode = 1;
+  return null;
+}
+async function loadCandidateOrFail(root, id) {
+  const candidate = await readCandidate(root, id);
+  if (!candidate) return failWithError(`Candidate not found: ${id}`);
+  return candidate;
+}
+async function loadCandidateUnderLockOrFail(root, id) {
+  const candidate = await readCandidate(root, id);
+  if (!candidate) {
+    return failWithError(`Candidate ${id} was removed by another process during review.`);
   }
+  return candidate;
 }
-async function detectSourceType(source2) {
-  if (!isUrl(source2)) {
-    const ext = path7.extname(source2).toLowerCase();
-    if (ext === ".pdf") return "pdf";
-    if (IMAGE_EXTENSIONS.has(ext)) return "image";
-    if (TRANSCRIPT_EXTENSIONS.has(ext)) return "transcript";
-    if (ext === ".txt") {
-      const isTranscript = await looksLikeTxtTranscript(source2);
-      return isTranscript ? "transcript" : "file";
-    }
-    return "file";
+async function readCandidate(root, id) {
+  const raw = await safeReadFile(candidatePath(root, id));
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isValidCandidate(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
   }
-  if (isYoutubeUrl(source2)) return "transcript";
-  return "web";
 }
-function buildDocument(title, source2, result, sourceType) {
-  const meta = {
-    title,
-    source: source2,
-    ingestedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  if (sourceType !== void 0) {
-    meta.sourceType = sourceType;
-  }
-  if (result.truncated) {
-    meta.truncated = true;
-    meta.originalChars = result.originalChars;
-  }
-  const frontmatter = buildFrontmatter(meta);
-  return `${frontmatter}
-
-${result.content}
-`;
+function isValidCandidate(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.id === "string" && typeof candidate.title === "string" && typeof candidate.slug === "string" && typeof candidate.body === "string" && Array.isArray(candidate.sources);
 }
-async function fetchContent(source2, sourceType) {
-  switch (sourceType) {
-    case "web":
-      return ingestWeb(source2);
-    case "pdf":
-      return ingestPdf(source2);
-    case "image":
-      return ingestImage(source2);
-    case "transcript":
-      return ingestTranscript(source2);
-    case "file":
-      return ingestFile(source2);
+async function listCandidates(root) {
+  const dir = path19.join(root, CANDIDATES_DIR);
+  if (!existsSync(dir)) return [];
+  const entries = await readdir3(dir, { withFileTypes: true });
+  const candidates = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(CANDIDATE_EXT)) continue;
+    const id = entry.name.slice(0, -CANDIDATE_EXT.length);
+    const candidate = await readCandidate(root, id);
+    if (candidate) candidates.push(candidate);
   }
+  candidates.sort((a, b) => a.generatedAt.localeCompare(b.generatedAt));
+  return candidates;
 }
-async function saveSource(title, document) {
-  const filename = `${slugify(title)}.md`;
-  const destPath = path7.join(SOURCES_DIR, filename);
-  await mkdir2(SOURCES_DIR, { recursive: true });
-  await writeFile2(destPath, document, "utf-8");
-  return destPath;
+async function countCandidates(root) {
+  const candidates = await listCandidates(root);
+  return candidates.length;
 }
-async function ingestSource(source2) {
-  const sourceType = await detectSourceType(source2);
-  status("*", info(`Ingesting [${sourceType}]: ${source2}`));
-  const { title, content } = await fetchContent(source2, sourceType);
-  const result = enforceCharLimit(content);
-  enforceMinContent(result.content);
-  const document = buildDocument(title, source2, result, sourceType);
-  const savedPath = await saveSource(title, document);
-  return {
-    filename: path7.basename(savedPath),
-    charCount: result.content.length,
-    truncated: result.truncated,
-    source: source2,
-    sourceType
-  };
+async function deleteCandidate(root, id) {
+  const filePath = candidatePath(root, id);
+  if (!existsSync(filePath)) return false;
+  await unlink(filePath);
+  return true;
 }
-async function ingest(source2) {
-  const result = await ingestSource(source2);
-  const savedPath = path7.join(SOURCES_DIR, result.filename);
-  status(
-    "+",
-    success(`Saved ${bold(result.filename)} \u2192 ${source(savedPath)}`)
-  );
-  status("\u2192", dim("Next: llmwiki compile"));
+async function archiveCandidate(root, id) {
+  const sourcePath = candidatePath(root, id);
+  if (!existsSync(sourcePath)) return false;
+  const target = archivePath(root, id);
+  await mkdir4(path19.dirname(target), { recursive: true });
+  try {
+    await rename2(sourcePath, target);
+  } catch {
+    const raw = await safeReadFile(sourcePath);
+    await writeFile3(target, raw, "utf-8");
+    await unlink(sourcePath);
+  }
+  return true;
 }
 
-// src/commands/compile.ts
-import { existsSync as existsSync7 } from "fs";
-
-// src/compiler/index.ts
-import { readFile as readFile14 } from "fs/promises";
-import path21 from "path";
-
 // src/utils/state.ts
-import { readFile as readFile7, writeFile as writeFile3, rename as rename2, mkdir as mkdir3, copyFile } from "fs/promises";
-import { existsSync } from "fs";
-import path8 from "path";
+import { readFile as readFile15, writeFile as writeFile4, rename as rename3, mkdir as mkdir5, copyFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import path20 from "path";
 function emptyState() {
   return { version: 1, indexHash: "", sources: {} };
 }
 async function readState(root) {
-  const filePath = path8.join(root, STATE_FILE);
-  if (!existsSync(filePath)) {
+  const filePath = path20.join(root, STATE_FILE);
+  if (!existsSync2(filePath)) {
     return emptyState();
   }
   try {
-    const raw = await readFile7(filePath, "utf-8");
+    const raw = await readFile15(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     const bakPath = filePath + ".bak";
@@ -850,12 +2382,12 @@ async function readState(root) {
   }
 }
 async function writeState(root, state) {
-  const dir = path8.join(root, LLMWIKI_DIR);
-  await mkdir3(dir, { recursive: true });
-  const filePath = path8.join(root, STATE_FILE);
+  const dir = path20.join(root, LLMWIKI_DIR);
+  await mkdir5(dir, { recursive: true });
+  const filePath = path20.join(root, STATE_FILE);
   const tmpPath = filePath + ".tmp";
-  await writeFile3(tmpPath, JSON.stringify(state, null, 2), "utf-8");
-  await rename2(tmpPath, filePath);
+  await writeFile4(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+  await rename3(tmpPath, filePath);
 }
 async function updateSourceState(root, sourceFile, entry) {
   const state = await readState(root);
@@ -868,20 +2400,226 @@ async function removeSourceState(root, sourceFile) {
   await writeState(root, state);
 }
 
+// src/viewer/snapshot.ts
+var RECENT_PAGES_LIMIT = 8;
+var INDEX_HREF = "/#/index";
+async function buildViewerSnapshot(root) {
+  const [pages, state, pendingReviews, sourceFilenames, index] = await Promise.all([
+    collectViewerPages(root),
+    readState(root),
+    countCandidates(root),
+    listSourceFiles(root),
+    readIndexFile(root)
+  ]);
+  const project = buildProject(root);
+  const counts = {
+    concepts: pages.filter((p) => p.pageDirectory === "concepts").length,
+    queries: pages.filter((p) => p.pageDirectory === "queries").length,
+    sourceFiles: sourceFilenames.length,
+    pendingReviews,
+    compiledSources: Object.keys(state.sources).length
+  };
+  const fullIndex = {
+    available: index.available,
+    href: INDEX_HREF,
+    body: index.body,
+    outgoingLinks: resolveBareSlugList(extractWikilinkSlugs(index.body), pages)
+  };
+  const sourceFileSet = new Set(sourceFilenames);
+  const annotatedPages = pages.map((page) => annotateCitationWarnings(page, sourceFileSet));
+  return {
+    root,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    project,
+    counts,
+    index: fullIndex,
+    recentPages: buildRecentPages(annotatedPages),
+    pages: annotatedPages,
+    sourceFilenames
+  };
+}
+function annotateCitationWarnings(page, sourceFiles) {
+  const extra = [];
+  const markerPattern = /\^\[([^\]\n]+)\]/g;
+  let match;
+  while ((match = markerPattern.exec(page.body)) !== null) {
+    appendCitationWarningsForMarker(match[1], sourceFiles, extra);
+  }
+  if (extra.length === 0) return page;
+  return { ...page, warnings: [...page.warnings, ...extra] };
+}
+function appendCitationWarningsForMarker(raw, sourceFiles, into) {
+  for (const entry of raw.split(",")) {
+    const trimmed = entry.trim();
+    if (trimmed.length === 0) continue;
+    if (isMalformedCitationEntry(trimmed)) {
+      into.push({
+        code: "malformed_citation",
+        message: `Malformed citation entry: ${trimmed}`
+      });
+      continue;
+    }
+    const file = trimmed.split(/[:#]/)[0];
+    if (file.length > 0 && !sourceFiles.has(file)) {
+      into.push({
+        code: "unresolved_citation",
+        message: `Source not found: ${file}`
+      });
+    }
+  }
+}
+function buildProject(root) {
+  const rootName = path21.basename(root);
+  return { title: rootName, rootName };
+}
+async function listSourceFiles(root) {
+  let canonicalRoot;
+  try {
+    canonicalRoot = await realpath3(root);
+  } catch {
+    return [];
+  }
+  const expectedDir = path21.join(canonicalRoot, SOURCES_DIR);
+  let realDir;
+  try {
+    realDir = await realpath3(expectedDir);
+  } catch {
+    return [];
+  }
+  if (realDir !== expectedDir) return [];
+  try {
+    const entries = await readdir4(realDir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function readIndexFile(root) {
+  let canonicalRoot;
+  try {
+    canonicalRoot = await realpath3(root);
+  } catch {
+    return { available: false, body: "" };
+  }
+  const expectedIndex = path21.join(canonicalRoot, "wiki", "index.md");
+  let resolved;
+  try {
+    resolved = await realpath3(expectedIndex);
+  } catch {
+    return { available: false, body: "" };
+  }
+  if (resolved !== expectedIndex) {
+    return { available: false, body: "" };
+  }
+  try {
+    const body = await readFile16(resolved, "utf-8");
+    return { available: true, body };
+  } catch {
+    return { available: false, body: "" };
+  }
+}
+function buildRecentPages(pages) {
+  const rows = pages.map((page) => ({
+    id: page.id,
+    pageDirectory: page.pageDirectory,
+    slug: page.slug,
+    title: page.title,
+    updatedAt: typeof page.frontmatter.updatedAt === "string" ? page.frontmatter.updatedAt : ""
+  }));
+  rows.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  return rows.slice(0, RECENT_PAGES_LIMIT);
+}
+
+// src/commands/view.ts
+var LOOPBACK_HOST = "127.0.0.1";
+var WILDCARD_HOSTS = /* @__PURE__ */ new Set([
+  "0.0.0.0",
+  "::",
+  "0:0:0:0:0:0:0:0",
+  "0000:0000:0000:0000:0000:0000:0000:0000",
+  "*"
+]);
+async function viewCommand(options) {
+  const { host, port } = resolveBindConfig(options);
+  const root = process.cwd();
+  const snapshot = await buildViewerSnapshot(root);
+  const handle = await startViewerServer(snapshot, { host, port });
+  const url = buildReadyUrl(handle.host, handle.port);
+  process.stdout.write(`Viewer ready at ${url}
+`);
+  if (options.open) openInBrowser(url);
+  registerShutdown(handle.close);
+}
+function openInBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = spawn(command, args, { stdio: "ignore", detached: true });
+  child.on("error", () => void 0);
+  child.unref();
+}
+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."
+    );
+  }
+  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 };
+}
+function buildReadyUrl(host, port) {
+  if (host.includes(":")) return `http://[${host}]:${port}`;
+  return `http://${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) {
+    throw new Error(`Invalid --port value: ${raw}`);
+  }
+  return value;
+}
+function registerShutdown(close) {
+  const shutdown = async () => {
+    try {
+      await close();
+      process.exit(0);
+    } catch {
+      process.exit(1);
+    }
+  };
+  process.once("SIGINT", () => void shutdown());
+  process.once("SIGTERM", () => void shutdown());
+}
+
+// src/commands/compile.ts
+import { existsSync as existsSync7 } from "fs";
+
+// src/compiler/index.ts
+import { readFile as readFile23 } from "fs/promises";
+import path33 from "path";
+
 // src/compiler/source-state.ts
-import path10 from "path";
+import path23 from "path";
 
 // src/compiler/hasher.ts
-import { createHash } from "crypto";
-import { readFile as readFile8, readdir } from "fs/promises";
-import path9 from "path";
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile17, readdir as readdir5 } from "fs/promises";
+import path22 from "path";
 async function hashFile(filePath) {
-  const content = await readFile8(filePath, "utf-8");
-  return createHash("sha256").update(content).digest("hex");
+  const content = await readFile17(filePath, "utf-8");
+  return createHash2("sha256").update(content).digest("hex");
 }
 async function detectChanges(root, prevState) {
-  const sourcesPath = path9.join(root, SOURCES_DIR);
-  const currentFiles = await listSourceFiles(sourcesPath);
+  const sourcesPath = path22.join(root, SOURCES_DIR);
+  const currentFiles = await listSourceFiles2(sourcesPath);
   const changes = [];
   for (const file of currentFiles) {
     const status2 = await classifyFile(root, file, prevState);
@@ -891,16 +2629,16 @@ async function detectChanges(root, prevState) {
   changes.push(...deletedChanges);
   return changes;
 }
-async function listSourceFiles(sourcesPath) {
+async function listSourceFiles2(sourcesPath) {
   try {
-    const entries = await readdir(sourcesPath);
+    const entries = await readdir5(sourcesPath);
     return entries.filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
 }
 async function classifyFile(root, file, prevState) {
-  const filePath = path9.join(root, SOURCES_DIR, file);
+  const filePath = path22.join(root, SOURCES_DIR, file);
   const hash = await hashFile(filePath);
   const prev = prevState.sources[file];
   if (!prev) return "new";
@@ -923,7 +2661,7 @@ async function buildExtractionSourceStates(root, extractions) {
   return snapshot;
 }
 async function buildEntry(root, result, compiledAt) {
-  const filePath = path10.join(root, SOURCES_DIR, result.sourceFile);
+  const filePath = path23.join(root, SOURCES_DIR, result.sourceFile);
   const hash = await hashFile(filePath);
   return {
     hash,
@@ -1012,7 +2750,8 @@ var OpenAIProvider = class {
       model: this.model,
       max_tokens: maxTokens,
       messages: [{ role: "system", content: system }, ...messages],
-      tools: openaiTools
+      tools: openaiTools,
+      tool_choice: "required"
     });
     const toolCalls = response.choices[0]?.message?.tool_calls;
     if (toolCalls && toolCalls.length > 0) {
@@ -1069,8 +2808,24 @@ var MiniMaxProvider = class extends OpenAIProvider {
   }
 };
 
+// src/providers/copilot.ts
+var CopilotProvider = class extends OpenAIProvider {
+  constructor(model, apiKey) {
+    super(model, { baseURL: COPILOT_BASE_URL, apiKey });
+  }
+  /**
+   * GitHub Copilot has no native embeddings API.
+   * Throws an informative error directing the user to an alternative.
+   */
+  async embed(_text) {
+    throw new Error(
+      "GitHub Copilot does not support embeddings.\n  For semantic search (llmwiki query), switch to the OpenAI provider:\n    export LLMWIKI_PROVIDER=openai\n    export OPENAI_API_KEY=sk-..."
+    );
+  }
+};
+
 // src/utils/provider.ts
-var SUPPORTED_PROVIDERS = /* @__PURE__ */ new Set(["anthropic", "openai", "ollama", "minimax"]);
+var SUPPORTED_PROVIDERS = /* @__PURE__ */ new Set(["anthropic", "openai", "ollama", "minimax", "copilot"]);
 function getProvider() {
   const providerName = getProviderName();
   switch (providerName) {
@@ -1090,6 +2845,8 @@ function getProvider() {
       });
     case "minimax":
       return getMiniMaxProvider();
+    case "copilot":
+      return getCopilotProvider();
     default:
       throw new Error(`Unhandled provider: ${providerName}`);
   }
@@ -1110,6 +2867,15 @@ function getMiniMaxProvider() {
   }
   return new MiniMaxProvider(getModelForProvider("minimax"), apiKey);
 }
+function getCopilotProvider() {
+  const apiKey = process.env.GITHUB_TOKEN;
+  if (!apiKey) {
+    throw new Error(
+      "GitHub Copilot provider requires GITHUB_TOKEN environment variable.\n  Run: gh auth refresh --scopes copilot\n  Then set it with: export GITHUB_TOKEN=$(gh auth token)\n  The token must belong to a GitHub account with an active Copilot subscription."
+    );
+  }
+  return new CopilotProvider(getModelForProvider("copilot"), apiKey);
+}
 function getAnthropicProvider() {
   const model = resolveAnthropicModelFromEnv() ?? PROVIDER_MODELS.anthropic;
   const baseURL = resolveAnthropicBaseURLFromEnv();
@@ -1161,8 +2927,8 @@ async function callClaude(options) {
 }
 
 // src/utils/lock.ts
-import { open, readFile as readFile9, unlink, mkdir as mkdir4 } from "fs/promises";
-import path11 from "path";
+import { open, readFile as readFile18, unlink as unlink2, mkdir as mkdir6 } from "fs/promises";
+import path24 from "path";
 var RECLAIM_SUFFIX = ".reclaim";
 var MAX_ACQUIRE_ATTEMPTS = 2;
 function isProcessAlive(pid) {
@@ -1174,8 +2940,8 @@ function isProcessAlive(pid) {
   }
 }
 async function acquireLock(root) {
-  const lockPath = path11.join(root, LOCK_FILE);
-  await mkdir4(path11.join(root, LLMWIKI_DIR), { recursive: true });
+  const lockPath = path24.join(root, LOCK_FILE);
+  await mkdir6(path24.join(root, LLMWIKI_DIR), { recursive: true });
   for (let attempt = 0; attempt < MAX_ACQUIRE_ATTEMPTS; attempt++) {
     const created = await tryCreateLock(lockPath);
     if (created) return true;
@@ -1199,7 +2965,7 @@ async function reclaimStaleLock(root, lockPath) {
       return false;
     }
     try {
-      await unlink(lockPath);
+      await unlink2(lockPath);
     } catch {
     }
     const acquired = await tryCreateLock(lockPath);
@@ -1209,7 +2975,7 @@ async function reclaimStaleLock(root, lockPath) {
     return acquired;
   } finally {
     try {
-      await unlink(reclaimPath);
+      await unlink2(reclaimPath);
     } catch {
     }
   }
@@ -1218,7 +2984,7 @@ async function acquireReclaimLock(reclaimPath) {
   if (await tryCreateLock(reclaimPath)) return true;
   if (!await isLockStale(reclaimPath)) return false;
   try {
-    await unlink(reclaimPath);
+    await unlink2(reclaimPath);
   } catch {
   }
   return false;
@@ -1238,7 +3004,7 @@ async function tryCreateLock(lockPath) {
 }
 async function isLockStale(lockPath) {
   try {
-    const content = await readFile9(lockPath, "utf-8");
+    const content = await readFile18(lockPath, "utf-8");
     const pid = parseInt(content.trim(), 10);
     if (isNaN(pid)) return true;
     return !isProcessAlive(pid);
@@ -1247,14 +3013,32 @@ async function isLockStale(lockPath) {
   }
 }
 async function releaseLock(root) {
-  const lockPath = path11.join(root, LOCK_FILE);
+  const lockPath = path24.join(root, LOCK_FILE);
   try {
-    await unlink(lockPath);
+    await unlink2(lockPath);
   } catch {
   }
 }
 
+// src/utils/output-language.ts
+var LANG_ENV_VAR = "LLMWIKI_OUTPUT_LANG";
+function getOutputLanguage() {
+  const raw = process.env[LANG_ENV_VAR];
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function languageDirective() {
+  const lang = getOutputLanguage();
+  if (!lang) return "";
+  return `Write the output in ${lang}.`;
+}
+
 // src/compiler/prompts.ts
+function withLangLine(...lines) {
+  const lang = languageDirective();
+  return lang ? [...lines, lang] : lines;
+}
 var PROVENANCE_STATE_VALUES = [
   "extracted",
   "merged",
@@ -1309,10 +3093,6 @@ var CONCEPT_EXTRACTION_TOOL = {
                 required: ["slug"]
               },
               description: "Slugs of other concepts whose evidence contradicts this one."
-            },
-            inferred_paragraphs: {
-              type: "integer",
-              description: "Estimated number of paragraphs in the page that will be inferred rather than directly cited."
             }
           },
           required: ["concept", "summary", "is_new"]
@@ -1329,11 +3109,13 @@ Here is the existing wiki index \u2014 avoid duplicating concepts already covere
 
 ${existingIndex}` : "\n\nNo existing wiki pages yet.";
   return [
-    "You are a knowledge extraction engine. Analyze the following source document",
-    "and identify 3-8 distinct, meaningful concepts worth documenting as wiki pages.",
-    "Each concept should be a standalone topic that someone might look up.",
-    "Focus on key ideas, techniques, patterns, or entities \u2014 not trivial details.",
-    "Use the extract_concepts tool to return your findings.",
+    ...withLangLine(
+      "You are a knowledge extraction engine. Analyze the following source document",
+      "and identify 3-8 distinct, meaningful concepts worth documenting as wiki pages.",
+      "Each concept should be a standalone topic that someone might look up.",
+      "Focus on key ideas, techniques, patterns, or entities \u2014 not trivial details.",
+      "Use the extract_concepts tool to return your findings."
+    ),
     "",
     "For every concept, emit provenance metadata so downstream tools can reason",
     "about reliability:",
@@ -1343,8 +3125,6 @@ ${existingIndex}` : "\n\nNo existing wiki pages yet.";
     "    or 'ambiguous' if the source is contradictory or unclear.",
     "  - contradicted_by: slugs of other concepts (in this batch or the index)",
     "    whose evidence conflicts with this one.",
-    "  - inferred_paragraphs: estimated number of paragraphs in the resulting",
-    "    page that will be inferred rather than directly citable.",
     indexSection,
     "\n\n--- SOURCE DOCUMENT ---\n\n",
     sourceContent
@@ -1362,11 +3142,13 @@ Related wiki pages for cross-referencing:
 
 ${relatedPages}` : "";
   return [
-    `You are a wiki author. Write a clear, well-structured markdown page about "${concept}".`,
-    "Draw facts only from the provided source material.",
-    "Include a ## Sources section at the end listing the source document.",
-    "Suggest [[wikilinks]] to related concepts where appropriate.",
-    "Write in a neutral, informative tone. Be concise but thorough.",
+    ...withLangLine(
+      `You are a wiki author. Write a clear, well-structured markdown page about "${concept}".`,
+      "Draw facts only from the provided source material.",
+      "Include a ## Sources section at the end listing the source document.",
+      "Suggest [[wikilinks]] to related concepts where appropriate.",
+      "Write in a neutral, informative tone. Be concise but thorough."
+    ),
     "",
     "Source attribution: at the end of each prose paragraph, append a citation",
     "marker showing which source file(s) the paragraph drew from.",
@@ -1383,7 +3165,7 @@ ${relatedPages}` : "";
     "",
     "If a paragraph is your inference rather than a direct extraction, leave it",
     "uncited \u2014 downstream lint rules will count uncited paragraphs as 'inferred'",
-    "to compute the page's provenance metadata.",
+    "so lint can surface excess-inferred-paragraphs warnings on review.",
     existingSection,
     relatedSection,
     "\n\n--- SOURCE MATERIAL ---\n\n",
@@ -1415,20 +3197,21 @@ function mapRawConcept(c) {
     tags: Array.isArray(c.tags) ? c.tags : void 0,
     confidence: typeof c.confidence === "number" ? c.confidence : void 0,
     provenanceState: provenance,
-    contradictedBy: coerceContradictedBy(c.contradicted_by),
-    inferredParagraphs: typeof c.inferred_paragraphs === "number" && Number.isInteger(c.inferred_paragraphs) && c.inferred_paragraphs >= 0 ? c.inferred_paragraphs : void 0
+    contradictedBy: coerceContradictedBy(c.contradicted_by)
   };
 }
 function buildSeedPagePrompt(seed, rule, relatedPagesContent) {
   const minLinks = rule.minWikilinks;
   const linkExpectation = minLinks > 0 ? `Include at least ${minLinks} [[wikilinks]] to related pages.` : "Use [[wikilinks]] when referencing other pages.";
   return [
-    `You are a wiki author. Write a ${seed.kind} page titled "${seed.title}".`,
-    `Page-kind guidance: ${rule.description}`,
-    `Summary line for context: ${seed.summary}`,
-    "Draw facts only from the related wiki pages provided below.",
-    linkExpectation,
-    "Write in a neutral, informative tone. Be concise but thorough.",
+    ...withLangLine(
+      `You are a wiki author. Write a ${seed.kind} page titled "${seed.title}".`,
+      `Page-kind guidance: ${rule.description}`,
+      `Summary line for context: ${seed.summary}`,
+      "Draw facts only from the related wiki pages provided below.",
+      linkExpectation,
+      "Write in a neutral, informative tone. Be concise but thorough."
+    ),
     "\n\n--- RELATED PAGES ---\n\n",
     relatedPagesContent
   ].join("\n");
@@ -1489,9 +3272,9 @@ function buildDefaultSchema() {
 }
 
 // src/schema/loader.ts
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile10 } from "fs/promises";
-import path12 from "path";
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile19 } from "fs/promises";
+import path25 from "path";
 import yaml2 from "js-yaml";
 var SCHEMA_CANDIDATE_PATHS = [
   ".llmwiki/schema.json",
@@ -1502,8 +3285,8 @@ var SCHEMA_CANDIDATE_PATHS = [
 ];
 function findSchemaPath(root) {
   for (const candidate of SCHEMA_CANDIDATE_PATHS) {
-    const absolute = path12.join(root, candidate);
-    if (existsSync2(absolute)) return absolute;
+    const absolute = path25.join(root, candidate);
+    if (existsSync3(absolute)) return absolute;
   }
   return null;
 }
@@ -1555,12 +3338,12 @@ async function loadSchema(root) {
   const defaults = buildDefaultSchema();
   const schemaPath = findSchemaPath(root);
   if (!schemaPath) return defaults;
-  const raw = await readFile10(schemaPath, "utf-8");
+  const raw = await readFile19(schemaPath, "utf-8");
   const parsed = parseSchemaFile(schemaPath, raw);
   return applyOverrides(defaults, parsed, schemaPath);
 }
 function defaultSchemaInitPath(root) {
-  return path12.join(root, SCHEMA_CANDIDATE_PATHS[0]);
+  return path25.join(root, SCHEMA_CANDIDATE_PATHS[0]);
 }
 
 // src/schema/helpers.ts
@@ -1732,7 +3515,7 @@ async function freezeFailedExtractions(root, results, frozenSlugs) {
 }
 
 // src/compiler/orphan.ts
-import path13 from "path";
+import path26 from "path";
 async function markOrphaned(root, sourceFile, state) {
   const sourceEntry = state.sources[sourceFile];
   if (!sourceEntry) return;
@@ -1758,7 +3541,7 @@ async function orphanUnownedFrozenPages(root, frozenSlugs) {
   }
 }
 async function orphanPage(root, slug, reason) {
-  const pagePath = path13.join(root, CONCEPTS_DIR, `${slug}.md`);
+  const pagePath = path26.join(root, CONCEPTS_DIR, `${slug}.md`);
   const content = await safeReadFile(pagePath);
   if (!content) return;
   const { meta } = parseFrontmatter(content);
@@ -1769,18 +3552,18 @@ async function orphanPage(root, slug, reason) {
 }
 
 // src/compiler/resolver.ts
-import { readdir as readdir2, readFile as readFile11 } from "fs/promises";
-import path14 from "path";
-import { existsSync as existsSync3 } from "fs";
+import { readdir as readdir6, readFile as readFile20 } from "fs/promises";
+import path27 from "path";
+import { existsSync as existsSync4 } from "fs";
 async function buildTitleIndex(root) {
-  const conceptsDir = path14.join(root, CONCEPTS_DIR);
-  if (!existsSync3(conceptsDir)) return [];
-  const files = await readdir2(conceptsDir);
+  const conceptsDir = path27.join(root, CONCEPTS_DIR);
+  if (!existsSync4(conceptsDir)) return [];
+  const files = await readdir6(conceptsDir);
   const pages = [];
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = path14.join(conceptsDir, file);
-    const content = await readFile11(filePath, "utf-8");
+    const filePath = path27.join(conceptsDir, file);
+    const content = await readFile20(filePath, "utf-8");
     const { meta } = parseFrontmatter(content);
     if (meta.title && typeof meta.title === "string" && !meta.orphaned) {
       pages.push({
@@ -1866,7 +3649,7 @@ async function resolveInboundLinks(titleIndex, newSlugs) {
   let count = 0;
   for (const page of titleIndex) {
     if (newSlugs.includes(page.slug)) continue;
-    const content = await readFile11(page.filePath, "utf-8");
+    const content = await readFile20(page.filePath, "utf-8");
     const { body } = parseFrontmatter(content);
     const linked = addWikilinks(body, newTitles, page.title);
     if (linked !== body) {
@@ -1878,7 +3661,7 @@ async function resolveInboundLinks(titleIndex, newSlugs) {
   return count;
 }
 async function linkPage(page, titleIndex) {
-  const content = await readFile11(page.filePath, "utf-8");
+  const content = await readFile20(page.filePath, "utf-8");
   const { body } = parseFrontmatter(content);
   const linked = addWikilinks(body, titleIndex, page.title);
   if (linked === body) return false;
@@ -1888,18 +3671,18 @@ async function linkPage(page, titleIndex) {
 }
 
 // src/compiler/indexgen.ts
-import { readdir as readdir3 } from "fs/promises";
-import path15 from "path";
+import { readdir as readdir7 } from "fs/promises";
+import path28 from "path";
 async function generateIndex(root) {
   status("*", info("Generating index..."));
-  const conceptsPath = path15.join(root, CONCEPTS_DIR);
-  const queriesPath = path15.join(root, QUERIES_DIR);
+  const conceptsPath = path28.join(root, CONCEPTS_DIR);
+  const queriesPath = path28.join(root, QUERIES_DIR);
   const concepts = await collectPageSummaries(conceptsPath);
   const queries = await collectPageSummaries(queriesPath);
   concepts.sort((a, b) => a.title.localeCompare(b.title));
   queries.sort((a, b) => a.title.localeCompare(b.title));
   const indexContent = buildIndexContent(concepts, queries);
-  const indexPath = path15.join(root, INDEX_FILE);
+  const indexPath = path28.join(root, INDEX_FILE);
   await atomicWrite(indexPath, indexContent);
   const total = concepts.length + queries.length;
   status("+", success(`Index updated with ${total} pages.`));
@@ -1907,13 +3690,13 @@ async function generateIndex(root) {
 async function scanWikiPages(dirPath) {
   let files;
   try {
-    files = await readdir3(dirPath);
+    files = await readdir7(dirPath);
   } catch {
     return [];
   }
   const scanned = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path15.join(dirPath, file));
+    const content = await safeReadFile(path28.join(dirPath, file));
     const { meta } = parseFrontmatter(content);
     scanned.push({ slug: file.replace(/\.md$/, ""), meta });
   }
@@ -1948,9 +3731,45 @@ function buildIndexContent(concepts, queries) {
   return lines.join("\n");
 }
 
+// src/compiler/prompt-budget.ts
+var TRUNCATION_MARKER = "\n\n[\u2026truncated for prompt budget \u2014 see #39\u2026]";
+function resolvePromptBudgetChars() {
+  const raw = process.env[PROMPT_BUDGET_ENV_VAR];
+  if (!raw) return DEFAULT_PROMPT_BUDGET_CHARS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_PROMPT_BUDGET_CHARS;
+  return parsed;
+}
+function buildBudgetedCombinedContent(concept, slices) {
+  const budget = resolvePromptBudgetChars();
+  const totalRaw = slices.reduce((sum, s) => sum + s.content.length, 0);
+  if (totalRaw <= budget) {
+    return formatSlices(slices);
+  }
+  const perSource = Math.max(1, Math.floor(budget / slices.length));
+  warnTruncation(concept, totalRaw, slices.length, perSource, budget);
+  const trimmed = slices.map(
+    (s) => s.content.length > perSource ? { ...s, content: s.content.slice(0, perSource) + TRUNCATION_MARKER } : s
+  );
+  return formatSlices(trimmed);
+}
+function formatSlices(slices) {
+  return slices.map((s) => `--- SOURCE: ${s.file} ---
+
+${s.content}`).join("\n\n");
+}
+function warnTruncation(concept, totalRaw, sourceCount, perSource, budget) {
+  status(
+    "!",
+    warn(
+      `Combined source content for "${concept}" (${totalRaw.toLocaleString()} chars across ${sourceCount} sources) exceeds the ${budget.toLocaleString()}-char prompt budget; truncating each source to ~${perSource.toLocaleString()} chars. Raise via ${PROMPT_BUDGET_ENV_VAR} when running against larger-context models.`
+    )
+  );
+}
+
 // src/compiler/obsidian.ts
-import { readdir as readdir4 } from "fs/promises";
-import path16 from "path";
+import { readdir as readdir8 } from "fs/promises";
+import path29 from "path";
 var ABBREVIATION_MIN_WORDS = 3;
 var SWAP_CONJUNCTIONS = [" and ", " or "];
 function addObsidianMeta(frontmatter, conceptTitle, tags) {
@@ -1992,23 +3811,23 @@ function generateAbbreviation(title) {
   return abbreviation;
 }
 async function generateMOC(root) {
-  const conceptsPath = path16.join(root, CONCEPTS_DIR);
+  const conceptsPath = path29.join(root, CONCEPTS_DIR);
   const pages = await loadConceptPages(conceptsPath);
   const tagGroups = groupPagesByTag(pages);
   const content = buildMOCContent(tagGroups);
-  await atomicWrite(path16.join(root, MOC_FILE), content);
+  await atomicWrite(path29.join(root, MOC_FILE), content);
 }
 async function loadConceptPages(conceptsPath) {
   let files;
   try {
-    files = await readdir4(conceptsPath);
+    files = await readdir8(conceptsPath);
   } catch {
     return [];
   }
   const pages = [];
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const content = await safeReadFile(path16.join(conceptsPath, file));
+    const content = await safeReadFile(path29.join(conceptsPath, file));
     if (!content) continue;
     const { meta } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -2059,14 +3878,14 @@ function buildMOCContent(tagGroups) {
 }
 
 // src/utils/embeddings.ts
-import { readFile as readFile12, readdir as readdir5 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import path17 from "path";
+import { readFile as readFile21, readdir as readdir9 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import path30 from "path";
 
 // src/utils/retrieval.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function hashChunkText(text) {
-  return createHash2("sha256").update(text, "utf8").digest("hex").slice(0, 16);
+  return createHash3("sha256").update(text, "utf8").digest("hex").slice(0, 16);
 }
 function splitIntoChunks(body) {
   const paragraphs = extractParagraphs(body);
@@ -2226,13 +4045,13 @@ function findTopKChunks(queryVec, chunks, k) {
   return scored.slice(0, k);
 }
 async function readEmbeddingStore(root) {
-  const filePath = path17.join(root, EMBEDDINGS_FILE);
-  if (!existsSync4(filePath)) return null;
-  const raw = await readFile12(filePath, "utf-8");
+  const filePath = path30.join(root, EMBEDDINGS_FILE);
+  if (!existsSync5(filePath)) return null;
+  const raw = await readFile21(filePath, "utf-8");
   return JSON.parse(raw);
 }
 async function writeEmbeddingStore(root, store) {
-  const filePath = path17.join(root, EMBEDDINGS_FILE);
+  const filePath = path30.join(root, EMBEDDINGS_FILE);
   await atomicWrite(filePath, JSON.stringify(store, null, 2));
 }
 async function findRelevantPages(root, question) {
@@ -2264,10 +4083,10 @@ async function loadActiveStore(root, hasContent) {
 async function collectPageRecords(root) {
   const records = [];
   for (const dir of [CONCEPTS_DIR, QUERIES_DIR]) {
-    const absDir = path17.join(root, dir);
+    const absDir = path30.join(root, dir);
     let files;
     try {
-      files = await readdir5(absDir);
+      files = await readdir9(absDir);
     } catch {
       continue;
     }
@@ -2279,7 +4098,7 @@ async function collectPageRecords(root) {
   return records;
 }
 async function readPageRecord(absDir, file) {
-  const content = await safeReadFile(path17.join(absDir, file));
+  const content = await safeReadFile(path30.join(absDir, file));
   const { meta, body } = parseFrontmatter(content);
   if (meta.orphaned || typeof meta.title !== "string") return null;
   return {
@@ -2440,114 +4259,10 @@ function shouldRunEmbedding(modelChanged, toEmbed, previousEntries, previousChun
   return false;
 }
 
-// src/compiler/candidates.ts
-import { readdir as readdir6, rename as rename3, unlink as unlink2, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import path18 from "path";
-import { randomBytes } from "crypto";
-var ID_SUFFIX_BYTES = 4;
-var CANDIDATE_EXT = ".json";
-function buildCandidateId(slug) {
-  const suffix = randomBytes(ID_SUFFIX_BYTES).toString("hex");
-  return `${slug}-${suffix}`;
-}
-function candidatePath(root, id) {
-  return path18.join(root, CANDIDATES_DIR, `${id}${CANDIDATE_EXT}`);
-}
-function archivePath(root, id) {
-  return path18.join(root, CANDIDATES_ARCHIVE_DIR, `${id}${CANDIDATE_EXT}`);
-}
-async function writeCandidate(root, draft) {
-  const candidate = {
-    id: buildCandidateId(draft.slug),
-    title: draft.title,
-    slug: draft.slug,
-    summary: draft.summary,
-    sources: draft.sources,
-    body: draft.body,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...draft.sourceStates ? { sourceStates: draft.sourceStates } : {},
-    ...draft.schemaViolations ? { schemaViolations: draft.schemaViolations } : {}
-  };
-  await atomicWrite(candidatePath(root, candidate.id), JSON.stringify(candidate, null, 2));
-  return candidate;
-}
-function failWithError(message) {
-  status("!", error(message));
-  process.exitCode = 1;
-  return null;
-}
-async function loadCandidateOrFail(root, id) {
-  const candidate = await readCandidate(root, id);
-  if (!candidate) return failWithError(`Candidate not found: ${id}`);
-  return candidate;
-}
-async function loadCandidateUnderLockOrFail(root, id) {
-  const candidate = await readCandidate(root, id);
-  if (!candidate) {
-    return failWithError(`Candidate ${id} was removed by another process during review.`);
-  }
-  return candidate;
-}
-async function readCandidate(root, id) {
-  const raw = await safeReadFile(candidatePath(root, id));
-  if (!raw) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (!isValidCandidate(parsed)) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function isValidCandidate(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return typeof candidate.id === "string" && typeof candidate.title === "string" && typeof candidate.slug === "string" && typeof candidate.body === "string" && Array.isArray(candidate.sources);
-}
-async function listCandidates(root) {
-  const dir = path18.join(root, CANDIDATES_DIR);
-  if (!existsSync5(dir)) return [];
-  const entries = await readdir6(dir, { withFileTypes: true });
-  const candidates = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(CANDIDATE_EXT)) continue;
-    const id = entry.name.slice(0, -CANDIDATE_EXT.length);
-    const candidate = await readCandidate(root, id);
-    if (candidate) candidates.push(candidate);
-  }
-  candidates.sort((a, b) => a.generatedAt.localeCompare(b.generatedAt));
-  return candidates;
-}
-async function countCandidates(root) {
-  const candidates = await listCandidates(root);
-  return candidates.length;
-}
-async function deleteCandidate(root, id) {
-  const filePath = candidatePath(root, id);
-  if (!existsSync5(filePath)) return false;
-  await unlink2(filePath);
-  return true;
-}
-async function archiveCandidate(root, id) {
-  const sourcePath = candidatePath(root, id);
-  if (!existsSync5(sourcePath)) return false;
-  const target = archivePath(root, id);
-  await mkdir5(path18.dirname(target), { recursive: true });
-  try {
-    await rename3(sourcePath, target);
-  } catch {
-    const raw = await safeReadFile(sourcePath);
-    await writeFile4(target, raw, "utf-8");
-    await unlink2(sourcePath);
-  }
-  return true;
-}
-
 // src/linter/rules.ts
-import { readdir as readdir7, readFile as readFile13 } from "fs/promises";
+import { readdir as readdir10, readFile as readFile22 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import path19 from "path";
+import path31 from "path";
 var MIN_BODY_LENGTH = 50;
 var WIKILINK_PATTERN2 = /\[\[([^\]]+)\]\]/g;
 var CITATION_PATTERN = /\^\[([^\]]+)\]/g;
@@ -2564,26 +4279,26 @@ function findMatchesInContent(content, pattern) {
 }
 async function readMarkdownFiles(dirPath) {
   if (!existsSync6(dirPath)) return [];
-  const entries = await readdir7(dirPath);
+  const entries = await readdir10(dirPath);
   const mdFiles = entries.filter((f) => f.endsWith(".md"));
   const results = await Promise.all(
     mdFiles.map(async (fileName) => {
-      const filePath = path19.join(dirPath, fileName);
-      const content = await readFile13(filePath, "utf-8");
+      const filePath = path31.join(dirPath, fileName);
+      const content = await readFile22(filePath, "utf-8");
       return { filePath, content };
     })
   );
   return results;
 }
 async function collectAllPages(root) {
-  const conceptPages = await readMarkdownFiles(path19.join(root, CONCEPTS_DIR));
-  const queryPages = await readMarkdownFiles(path19.join(root, QUERIES_DIR));
+  const conceptPages = await readMarkdownFiles(path31.join(root, CONCEPTS_DIR));
+  const queryPages = await readMarkdownFiles(path31.join(root, QUERIES_DIR));
   return [...conceptPages, ...queryPages];
 }
 function buildPageSlugSet(pages) {
   const slugs = /* @__PURE__ */ new Set();
   for (const page of pages) {
-    const baseName = path19.basename(page.filePath, ".md");
+    const baseName = path31.basename(page.filePath, ".md");
     slugs.add(baseName.toLowerCase());
   }
   return slugs;
@@ -2730,9 +4445,8 @@ async function checkInferredWithoutCitations(root) {
   const pages = await collectAllPages(root);
   const results = [];
   for (const page of pages) {
-    const { meta, body } = parseFrontmatter(page.content);
-    const provenance = parseProvenanceMetadata(meta);
-    const inferred = provenance.inferredParagraphs ?? countUncitedProseParagraphs(body);
+    const { body } = parseFrontmatter(page.content);
+    const inferred = countUncitedProseParagraphs(body);
     if (inferred <= MAX_INFERRED_PARAGRAPHS_WITHOUT_CITATIONS) continue;
     results.push({
       rule: "excess-inferred-paragraphs",
@@ -2743,7 +4457,7 @@ async function checkInferredWithoutCitations(root) {
   }
   return results;
 }
-var PROSE_PARAGRAPH_LEAD = /^[A-Za-z]/;
+var PROSE_PARAGRAPH_LEAD = new RegExp("^\\p{L}", "u");
 function countUncitedProseParagraphs(body) {
   const paragraphs = body.split(/\n\s*\n/);
   let count = 0;
@@ -2766,18 +4480,7 @@ async function checkSchemaCrossLinks(root, schema) {
   const pages = await collectAllPages(root);
   const results = [];
   for (const page of pages) {
-    const { meta, body } = parseFrontmatter(page.content);
-    const kind = resolvePageKind(meta.kind, schema);
-    const rule = schema.kinds[kind];
-    if (rule.minWikilinks <= 0) continue;
-    const linkCount = countWikilinks(body);
-    if (linkCount >= rule.minWikilinks) continue;
-    results.push({
-      rule: "schema-cross-link-minimum",
-      severity: "warning",
-      file: page.filePath,
-      message: `Page kind "${kind}" requires at least ${rule.minWikilinks} [[wikilinks]] but only ${linkCount} found.`
-    });
+    results.push(...checkPageCrossLinks(page.content, page.filePath, schema));
   }
   return results;
 }
@@ -2818,13 +4521,24 @@ function countLines(content) {
 }
 async function checkBrokenCitations(root) {
   const pages = await collectAllPages(root);
-  const sourcesDir = path19.join(root, SOURCES_DIR);
+  const sourcesDir = path31.join(root, SOURCES_DIR);
   const results = [];
   const lineCountCache = /* @__PURE__ */ new Map();
   for (const page of pages) {
-    for (const { captured, line } of findMatchesInContent(page.content, CITATION_PATTERN)) {
-      await collectBrokenForMarker(captured, line, page.filePath, sourcesDir, lineCountCache, results);
-    }
+    const pageFindings = await checkPageBrokenCitations(
+      page.content,
+      page.filePath,
+      sourcesDir,
+      lineCountCache
+    );
+    results.push(...pageFindings);
+  }
+  return results;
+}
+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);
   }
   return results;
 }
@@ -2833,7 +4547,7 @@ async function collectBrokenForMarker(captured, line, pageFile, sourcesDir, line
     const trimmed = part.trim();
     if (trimmed.length === 0) continue;
     const filename = stripSpanSuffix(trimmed);
-    const citedPath = path19.join(sourcesDir, filename);
+    const citedPath = path31.join(sourcesDir, filename);
     if (!existsSync6(citedPath)) {
       out.push({
         rule: "broken-citation",
@@ -2869,25 +4583,30 @@ async function checkMalformedClaimCitations(root) {
   const pages = await collectAllPages(root);
   const results = [];
   for (const page of pages) {
-    for (const { captured, line } of findMatchesInContent(page.content, CITATION_PATTERN)) {
-      for (const part of captured.split(",")) {
-        if (!isMalformedCitationEntry(part)) continue;
-        results.push({
-          rule: "malformed-claim-citation",
-          severity: "error",
-          file: page.filePath,
-          message: `Malformed claim citation ^[${captured}] \u2014 expected file.md, file.md:N-N, or file.md#LN-LN`,
-          line
-        });
-      }
+    results.push(...checkPageMalformedCitations(page.content, page.filePath));
+  }
+  return results;
+}
+function checkPageMalformedCitations(content, filePath) {
+  const results = [];
+  for (const { captured, line } of findMatchesInContent(content, CITATION_PATTERN)) {
+    for (const part of captured.split(",")) {
+      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
+      });
     }
   }
   return results;
 }
 
 // src/compiler/page-renderer.ts
-import { readdir as readdir8 } from "fs/promises";
-import path20 from "path";
+import { readdir as readdir11 } from "fs/promises";
+import path32 from "path";
 
 // src/compiler/provenance.ts
 function addProvenanceMeta(fields, concept) {
@@ -2900,9 +4619,6 @@ function addProvenanceMeta(fields, concept) {
   if (concept.contradictedBy && concept.contradictedBy.length > 0) {
     fields.contradictedBy = concept.contradictedBy;
   }
-  if (typeof concept.inferredParagraphs === "number") {
-    fields.inferredParagraphs = concept.inferredParagraphs;
-  }
 }
 function reportContradictionWarnings(conceptTitle, concept) {
   const refs = concept.contradictedBy;
@@ -2917,7 +4633,7 @@ function reportContradictionWarnings(conceptTitle, concept) {
 // src/compiler/page-renderer.ts
 var RELATED_PAGE_CONTEXT_LIMIT = 5;
 async function renderMergedPageContent(root, entry, schema) {
-  const pagePath = path20.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
+  const pagePath = path32.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
   const existingPage = await safeReadFile(pagePath);
   const relatedPages = await loadRelatedPages(root, entry.slug);
   const system = buildPagePrompt(
@@ -2956,17 +4672,17 @@ function buildMergedFrontmatter(entry, existingPage, schema) {
   return buildFrontmatter(frontmatterFields);
 }
 async function loadRelatedPages(root, excludeSlug) {
-  const conceptsPath = path20.join(root, CONCEPTS_DIR);
+  const conceptsPath = path32.join(root, CONCEPTS_DIR);
   let files;
   try {
-    files = await readdir8(conceptsPath);
+    files = await readdir11(conceptsPath);
   } catch {
     return "";
   }
   const related = files.filter((f) => f.endsWith(".md") && f !== `${excludeSlug}.md`).slice(0, RELATED_PAGE_CONTEXT_LIMIT);
   const contents = [];
   for (const f of related) {
-    const content = await safeReadFile(path20.join(conceptsPath, f));
+    const content = await safeReadFile(path32.join(conceptsPath, f));
     if (!content) continue;
     const { meta } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -3020,7 +4736,7 @@ async function generatePagesPhase(root, extractions, frozenSlugs, schema, option
       return entry;
     }))
   );
-  return { pages, errors, candidates };
+  return { pages, errors, candidates, seedSlugs: [] };
 }
 async function persistExtractionStates(root, extractions) {
   for (const result of extractions) {
@@ -3046,12 +4762,13 @@ function summarizeCompile(buckets, generation, extractions, options) {
       errors.push(`No concepts extracted from ${result.sourceFile}`);
     }
   }
+  const conceptSlugs = generation.pages.map((entry) => entry.slug);
   const baseResult = {
     compiled: buckets.toCompile.length,
     skipped: buckets.unchanged.length,
     deleted: buckets.deleted.length,
     concepts: generation.pages.map((entry) => entry.concept.concept),
-    pages: generation.pages.map((entry) => entry.slug),
+    pages: [...conceptSlugs, ...generation.seedSlugs],
     errors
   };
   if (options.review) {
@@ -3069,12 +4786,21 @@ async function runCompilePipeline(root, options) {
   if (buckets.toCompile.length === 0 && buckets.deleted.length === 0) {
     status("\u2713", success("Nothing to compile \u2014 all sources up to date."));
     if (!options.review) {
-      const emptyGeneration = { pages: [], errors: [], candidates: [] };
+      const emptyGeneration = {
+        pages: [],
+        errors: [],
+        candidates: [],
+        seedSlugs: []
+      };
       await generateSeedPages(root, schema, emptyGeneration);
-      await finalizeWiki(root, emptyGeneration.pages);
+      await finalizeWiki(root, emptyGeneration.pages, emptyGeneration.seedSlugs);
       return {
         ...emptyCompileResult(),
         skipped: buckets.unchanged.length,
+        // Surface seed-page slugs alongside any errors so downstream
+        // consumers (MCP, embeddings, programmatic callers) can see what
+        // landed even on the no-source-changes early-return path.
+        pages: [...emptyGeneration.seedSlugs],
         errors: emptyGeneration.errors
       };
     }
@@ -3098,7 +4824,7 @@ async function runCompilePipeline(root, options) {
     }
     await persistFrozenSlugs(root, frozenSlugs, extractions);
     await generateSeedPages(root, schema, generation);
-    await finalizeWiki(root, generation.pages);
+    await finalizeWiki(root, generation.pages, generation.seedSlugs);
   }
   return summarizeCompile(buckets, generation, extractions, options);
 }
@@ -3135,9 +4861,11 @@ async function runExtractionPhases(root, toCompile, state, allChanges) {
   }
   return extractions;
 }
-async function finalizeWiki(root, pages) {
-  const allChangedSlugs = pages.map((entry) => entry.slug);
-  const allNewSlugs = pages.filter((entry) => entry.concept.is_new).map((entry) => entry.slug);
+async function finalizeWiki(root, pages, seedSlugs = []) {
+  const conceptChangedSlugs = pages.map((entry) => entry.slug);
+  const conceptNewSlugs = pages.filter((entry) => entry.concept.is_new).map((entry) => entry.slug);
+  const allChangedSlugs = [...conceptChangedSlugs, ...seedSlugs];
+  const allNewSlugs = [...conceptNewSlugs, ...seedSlugs];
   if (allChangedSlugs.length > 0) {
     status("\u{1F517}", info("Resolving interlinks..."));
     await resolveLinks(root, allChangedSlugs, allNewSlugs);
@@ -3167,9 +4895,9 @@ function printChangesSummary(changes) {
 }
 async function extractForSource(root, sourceFile) {
   status("*", info(`Extracting: ${sourceFile}`));
-  const sourcePath = path21.join(root, SOURCES_DIR, sourceFile);
-  const sourceContent = await readFile14(sourcePath, "utf-8");
-  const existingIndex = await safeReadFile(path21.join(root, INDEX_FILE));
+  const sourcePath = path33.join(root, SOURCES_DIR, sourceFile);
+  const sourceContent = await readFile23(sourcePath, "utf-8");
+  const existingIndex = await safeReadFile(path33.join(root, INDEX_FILE));
   const concepts = await extractConcepts(sourceContent, existingIndex);
   if (concepts.length > 0) {
     const names = concepts.map((c) => c.concept).join(", ");
@@ -3192,13 +4920,11 @@ function reconcileConceptMetadata(existing, incoming) {
     }
   }
   reconciled.contradictedBy = refs.length > 0 ? refs : void 0;
-  if (typeof incoming.inferredParagraphs === "number") {
-    reconciled.inferredParagraphs = typeof existing.inferredParagraphs === "number" ? Math.max(existing.inferredParagraphs, incoming.inferredParagraphs) : incoming.inferredParagraphs;
-  }
   return reconciled;
 }
 function mergeExtractions(extractions, frozenSlugs) {
   const bySlug = /* @__PURE__ */ new Map();
+  const slicesBySlug = /* @__PURE__ */ new Map();
   for (const result of extractions) {
     if (result.concepts.length === 0) continue;
     for (const concept of result.concepts) {
@@ -3208,23 +4934,28 @@ function mergeExtractions(extractions, frozenSlugs) {
       if (existing) {
         existing.concept = reconcileConceptMetadata(existing.concept, concept);
         existing.sourceFiles.push(result.sourceFile);
-        existing.combinedContent += `
-
---- SOURCE: ${result.sourceFile} ---
-
-${result.sourceContent}`;
       } else {
         bySlug.set(slug, {
           slug,
           concept,
           sourceFiles: [result.sourceFile],
-          combinedContent: `--- SOURCE: ${result.sourceFile} ---
-
-${result.sourceContent}`
+          combinedContent: ""
         });
+        slicesBySlug.set(slug, []);
       }
+      slicesBySlug.get(slug).push({
+        file: result.sourceFile,
+        content: result.sourceContent
+      });
     }
   }
+  for (const merged of bySlug.values()) {
+    const slices = slicesBySlug.get(merged.slug) ?? [];
+    merged.combinedContent = buildBudgetedCombinedContent(
+      merged.concept.concept,
+      slices
+    );
+  }
   return Array.from(bySlug.values());
 }
 async function generateMergedPage(root, entry, schema, options, sourceStates) {
@@ -3232,13 +4963,18 @@ async function generateMergedPage(root, entry, schema, options, sourceStates) {
   if (options.review) {
     return await persistReviewCandidate(root, entry, fullPage, sourceStates, schema);
   }
-  const pagePath = path21.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
+  const pagePath = path33.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
   const error2 = await writePageIfValid(pagePath, fullPage, entry.concept.concept);
   return { error: error2 ?? void 0 };
 }
 async function persistReviewCandidate(root, entry, fullPage, sourceStates, schema) {
   const virtualPath = `wiki/concepts/${entry.slug}.md`;
-  const violations = checkPageCrossLinks(fullPage, virtualPath, schema);
+  const schemaViolations = checkPageCrossLinks(fullPage, virtualPath, schema);
+  const provenanceViolations = await collectCandidateProvenanceViolations(
+    root,
+    fullPage,
+    virtualPath
+  );
   const candidate = await writeCandidate(root, {
     title: entry.concept.concept,
     slug: entry.slug,
@@ -3246,21 +4982,35 @@ async function persistReviewCandidate(root, entry, fullPage, sourceStates, schem
     sources: entry.sourceFiles,
     body: fullPage,
     sourceStates: pickStatesForSources(sourceStates, entry.sourceFiles),
-    schemaViolations: violations.length > 0 ? violations : void 0
+    schemaViolations: schemaViolations.length > 0 ? schemaViolations : void 0,
+    provenanceViolations: provenanceViolations.length > 0 ? provenanceViolations : void 0
   });
   status("?", info(`Candidate ready: ${candidate.id} (${entry.slug})`));
   return { candidateId: candidate.id };
 }
+async function collectCandidateProvenanceViolations(root, fullPage, virtualPath) {
+  const malformed = checkPageMalformedCitations(fullPage, virtualPath);
+  const broken = await checkPageBrokenCitations(
+    fullPage,
+    virtualPath,
+    path33.join(root, SOURCES_DIR)
+  );
+  return [...malformed, ...broken];
+}
 async function generateSeedPages(root, schema, generation) {
   if (schema.seedPages.length === 0) return;
   for (const seed of schema.seedPages) {
-    const error2 = await generateSingleSeedPage(root, schema, seed);
-    if (error2) generation.errors.push(error2);
+    const result = await generateSingleSeedPage(root, schema, seed);
+    if (result.error) {
+      generation.errors.push(result.error);
+      continue;
+    }
+    generation.seedSlugs.push(result.slug);
   }
 }
 async function generateSingleSeedPage(root, schema, seed) {
   const slug = slugify(seed.title);
-  const pagePath = path21.join(root, CONCEPTS_DIR, `${slug}.md`);
+  const pagePath = path33.join(root, CONCEPTS_DIR, `${slug}.md`);
   const relatedContent = await loadSeedRelatedPages(root, seed.relatedSlugs ?? []);
   const rule = schema.kinds[seed.kind];
   const system = buildSeedPagePrompt(seed, rule, relatedContent);
@@ -3283,16 +5033,17 @@ async function generateSingleSeedPage(root, schema, seed) {
   const frontmatterFields = { ...typedFields };
   addObsidianMeta(frontmatterFields, seed.title, []);
   const frontmatter = buildFrontmatter(frontmatterFields);
-  return await writePageIfValid(pagePath, `${frontmatter}
+  const error2 = await writePageIfValid(pagePath, `${frontmatter}
 
 ${pageBody}
 `, seed.title);
+  return error2 ? { slug, error: error2 } : { slug };
 }
 async function loadSeedRelatedPages(root, slugs) {
   if (slugs.length === 0) return "";
   const contents = [];
   for (const slug of slugs) {
-    const pagePath = path21.join(root, CONCEPTS_DIR, `${slug}.md`);
+    const pagePath = path33.join(root, CONCEPTS_DIR, `${slug}.md`);
     const content = await safeReadFile(pagePath);
     if (content) contents.push(content);
   }
@@ -3347,7 +5098,7 @@ async function compileCommand(options = {}) {
 
 // src/commands/query.ts
 import { existsSync as existsSync8 } from "fs";
-import path22 from "path";
+import path34 from "path";
 var PAGE_DIRS = [CONCEPTS_DIR, QUERIES_DIR];
 var PAGE_SELECTION_TOOL = {
   name: "select_pages",
@@ -3404,7 +5155,7 @@ async function selectRelevantPages(root, question, debug) {
     const { pages: rawPages2, reasoning: reasoning2 } = await selectPages(question, filteredIndex);
     return { pages: rawPages2, rawPages: rawPages2, reasoning: reasoning2, chunks: [] };
   }
-  const indexContent = await safeReadFile(path22.join(root, INDEX_FILE));
+  const indexContent = await safeReadFile(path34.join(root, INDEX_FILE));
   const { pages: rawPages, reasoning } = await selectPages(question, indexContent);
   return { pages: rawPages.map((p) => slugify(p)), rawPages, reasoning, chunks: [] };
 }
@@ -3496,7 +5247,7 @@ async function loadSelectedPages(root, slugs) {
   for (const slug of slugs) {
     let content = "";
     for (const dir of PAGE_DIRS) {
-      const candidate = await safeReadFile(path22.join(root, dir, `${slug}.md`));
+      const candidate = await safeReadFile(path34.join(root, dir, `${slug}.md`));
       if (!candidate) continue;
       const { meta } = parseFrontmatter(candidate);
       if (meta.orphaned) continue;
@@ -3512,7 +5263,11 @@ ${content}`);
   }
   return sections.join("\n\n");
 }
-var ANSWER_SYSTEM_PROMPT = "You are a knowledge assistant. Answer the question using ONLY the wiki content provided. Cite specific pages using [[Page Title]] wikilinks. If the wiki doesn't contain enough information, say so.";
+var ANSWER_SYSTEM_PROMPT_BASE = "You are a knowledge assistant. Answer the question using ONLY the wiki content provided. Cite specific pages using [[Page Title]] wikilinks. If the wiki doesn't contain enough information, say so.";
+function buildAnswerSystemPrompt() {
+  const lang = languageDirective();
+  return lang ? `${ANSWER_SYSTEM_PROMPT_BASE} ${lang}` : ANSWER_SYSTEM_PROMPT_BASE;
+}
 async function callAnswerLLM(question, pagesContent, chunks, onToken) {
   const provenance = chunks.length > 0 ? buildChunkProvenance(chunks) : "";
   const userMessage = `Question: ${question}
@@ -3520,7 +5275,7 @@ async function callAnswerLLM(question, pagesContent, chunks, onToken) {
 Relevant wiki pages:
 ${pagesContent}${provenance}`;
   return callClaude({
-    system: ANSWER_SYSTEM_PROMPT,
+    system: buildAnswerSystemPrompt(),
     messages: [{ role: "user", content: userMessage }],
     stream: Boolean(onToken),
     onToken
@@ -3543,7 +5298,7 @@ function summarizeAnswer(answer) {
 }
 async function saveQueryPage(root, question, answer) {
   const slug = slugify(question);
-  const filePath = path22.join(root, QUERIES_DIR, `${slug}.md`);
+  const filePath = path34.join(root, QUERIES_DIR, `${slug}.md`);
   const frontmatter = buildFrontmatter({
     title: question,
     summary: summarizeAnswer(answer),
@@ -3569,7 +5324,7 @@ ${answer}
   return slug;
 }
 async function generateAnswer(root, question, options = {}) {
-  if (!existsSync8(path22.join(root, INDEX_FILE))) {
+  if (!existsSync8(path34.join(root, INDEX_FILE))) {
     throw new Error("Wiki index not found. Run `llmwiki compile` first.");
   }
   const selection = await selectRelevantPages(root, question, Boolean(options.debug));
@@ -3597,7 +5352,7 @@ function buildEmptyResult(selection) {
   };
 }
 async function queryCommand(root, question, options) {
-  if (!existsSync8(path22.join(root, INDEX_FILE))) {
+  if (!existsSync8(path34.join(root, INDEX_FILE))) {
     status("!", error("Wiki index not found. Run `llmwiki compile` first."));
     return;
   }
@@ -3648,10 +5403,10 @@ var DEBUG_CHUNK_PREVIEW_CHARS = 120;
 // src/commands/watch.ts
 import { watch as chokidarWatch } from "chokidar";
 import { existsSync as existsSync9 } from "fs";
-import path23 from "path";
+import path35 from "path";
 var DEBOUNCE_MS = 500;
 async function watchCommand() {
-  const sourcesPath = path23.resolve(SOURCES_DIR);
+  const sourcesPath = path35.resolve(SOURCES_DIR);
   if (!existsSync9(sourcesPath)) {
     status(
       "!",
@@ -3686,7 +5441,7 @@ async function watchCommand() {
   const scheduleCompile = (eventPath, event) => {
     status(
       "~",
-      dim(`${event}: ${path23.basename(eventPath)}`)
+      dim(`${event}: ${path35.basename(eventPath)}`)
     );
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(triggerCompile, DEBOUNCE_MS);
@@ -3765,15 +5520,356 @@ async function lintCommand() {
     info(`${summary.info} info`)
   ].join(", ");
   status("*", summaryLine);
+  await writeLintCache(process.cwd(), summary);
   if (summary.errors > 0) {
     process.exit(1);
   }
 }
 
+// src/commands/export.ts
+import path36 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);
+}
+var KEY_DEFS = [
+  '<key id="title"     for="node" attr.name="title"     attr.type="string"/>',
+  '<key id="summary"   for="node" attr.name="summary"   attr.type="string"/>',
+  '<key id="tags"      for="node" attr.name="tags"      attr.type="string"/>',
+  '<key id="sources"   for="node" attr.name="sources"   attr.type="string"/>',
+  '<key id="createdAt" for="node" attr.name="createdAt" attr.type="string"/>',
+  '<key id="updatedAt" for="node" attr.name="updatedAt" attr.type="string"/>'
+].join("\n  ");
+function pageToNode(page) {
+  const tags = page.tags.join(", ");
+  const sources = page.sources.join(", ");
+  return [
+    `  <node id="${escapeXml(page.slug)}">`,
+    `    <data key="title">${escapeXml(page.title)}</data>`,
+    `    <data key="summary">${escapeXml(page.summary)}</data>`,
+    `    <data key="tags">${escapeXml(tags)}</data>`,
+    `    <data key="sources">${escapeXml(sources)}</data>`,
+    `    <data key="createdAt">${escapeXml(page.createdAt)}</data>`,
+    `    <data key="updatedAt">${escapeXml(page.updatedAt)}</data>`,
+    `  </node>`
+  ].join("\n");
+}
+function pageToEdges(page, knownSlugs) {
+  return page.links.filter((slug) => knownSlugs.has(slug)).map(
+    (slug) => `  <edge source="${escapeXml(page.slug)}" target="${escapeXml(slug)}"/>`
+  );
+}
+function buildGraphml(pages) {
+  const knownSlugs = new Set(pages.map((p) => p.slug));
+  const nodes = pages.map(pageToNode).join("\n");
+  const edges = pages.flatMap((p) => pageToEdges(p, knownSlugs)).join("\n");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<graphml xmlns="http://graphml.graphdrawing.org/graphml"',
+    '         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"',
+    '         xsi:schemaLocation="http://graphml.graphdrawing.org/graphml',
+    '           http://graphml.graphdrawing.org/graphml/1.0/graphml.xsd">',
+    `  ${KEY_DEFS}`,
+    '  <graph id="wiki" edgedefault="directed">',
+    nodes,
+    edges,
+    "  </graph>",
+    "</graphml>",
+    ""
+  ].join("\n");
+}
+
+// src/export/marp.ts
+var SLIDE_BODY_MAX_CHARS = 300;
+function extractFirstParagraph(body) {
+  const trimmed = body.trim();
+  const firstBlock = trimmed.split(/\n\s*\n/)[0] ?? "";
+  const stripped = firstBlock.replace(/^#{1,6}\s+/gm, "").replace(/^[-*+]\s+/gm, "").trim();
+  if (stripped.length <= SLIDE_BODY_MAX_CHARS) return stripped;
+  return `${stripped.slice(0, SLIDE_BODY_MAX_CHARS)}\u2026`;
+}
+function buildSpeakerNotes(page) {
+  const parts = [`created: ${page.createdAt}`, `updated: ${page.updatedAt}`];
+  if (page.sources.length > 0) parts.push(`sources: ${page.sources.join(", ")}`);
+  return `<!-- ${parts.join(" | ")} -->`;
+}
+function pageToSlide(page) {
+  const tagLine = page.tags.length > 0 ? `
+_Tags: ${page.tags.join(", ")}_` : "";
+  const excerpt = extractFirstParagraph(page.body);
+  const notes = buildSpeakerNotes(page);
+  return [
+    `## ${page.title}`,
+    "",
+    `> ${page.summary}${tagLine}`,
+    "",
+    excerpt,
+    "",
+    notes
+  ].join("\n");
+}
+function filterBySource(pages, source2) {
+  if (source2 === "all") return pages;
+  return pages.filter((p) => p.pageDirectory === source2);
+}
+function buildMarp(pages, projectTitle, source2 = "all") {
+  const filtered = filterBySource(pages, source2);
+  const frontmatter = [
+    "---",
+    "marp: true",
+    "theme: default",
+    "paginate: true",
+    `title: "${projectTitle}"`,
+    "---"
+  ].join("\n");
+  const titleSlide = [
+    "",
+    `# ${projectTitle}`,
+    "",
+    `${filtered.length} pages | ${(/* @__PURE__ */ new Date()).toISOString()}`
+  ].join("\n");
+  const slides = filtered.map((p) => `---
+
+${pageToSlide(p)}`);
+  return [frontmatter, titleSlide, ...slides, ""].join("\n\n");
+}
+
+// src/export/types.ts
+var MARP_SOURCES = ["concepts", "queries", "all"];
+var EXPORT_TARGETS = [
+  "llms-txt",
+  "llms-full-txt",
+  "json",
+  "json-ld",
+  "graphml",
+  "marp"
+];
+
+// src/commands/export.ts
+var require2 = createRequire(import.meta.url);
+var EXPORT_DIR = "dist/exports";
+var TARGET_FILENAMES = {
+  "llms-txt": "llms.txt",
+  "llms-full-txt": "llms-full.txt",
+  json: "wiki.json",
+  "json-ld": "wiki.jsonld",
+  graphml: "wiki.graphml",
+  marp: "wiki.md"
+};
+function resolveProjectTitle(root) {
+  try {
+    const pkg = require2(path36.join(root, "package.json"));
+    return typeof pkg.name === "string" ? pkg.name : "Knowledge Wiki";
+  } catch {
+    return "Knowledge Wiki";
+  }
+}
+function isValidTarget(value) {
+  return EXPORT_TARGETS.includes(value);
+}
+function isValidMarpSource(value) {
+  return MARP_SOURCES.includes(value);
+}
+function resolveMarpSource(rawSource) {
+  if (!rawSource) return "all";
+  if (!isValidMarpSource(rawSource)) {
+    throw new Error(
+      `Unknown --source value "${rawSource}". Valid values: ${MARP_SOURCES.join(", ")}`
+    );
+  }
+  return rawSource;
+}
+function buildContent(target, pages, projectTitle, marpSource) {
+  switch (target) {
+    case "llms-txt":
+      return buildLlmsTxt(pages, projectTitle);
+    case "llms-full-txt":
+      return buildLlmsFullTxt(pages, projectTitle);
+    case "json":
+      return buildJsonExport(pages);
+    case "json-ld":
+      return buildJsonLd(pages);
+    case "graphml":
+      return buildGraphml(pages);
+    case "marp":
+      return buildMarp(pages, projectTitle, marpSource);
+  }
+}
+function computeReportedPageCount(pages, targets, marpSource) {
+  const onlyMarpTarget = targets.length === 1 && targets[0] === "marp";
+  if (onlyMarpTarget && marpSource !== "all") {
+    return pages.filter((p) => p.pageDirectory === marpSource).length;
+  }
+  return pages.length;
+}
+async function runExport(root, options = {}) {
+  const pages = await collectExportPages(root);
+  const projectTitle = resolveProjectTitle(root);
+  const targets = resolveTargets(options.target);
+  const marpSource = resolveMarpSource(options.source);
+  const written = [];
+  for (const target of targets) {
+    const content = buildContent(target, pages, projectTitle, marpSource);
+    const outPath = path36.join(root, EXPORT_DIR, TARGET_FILENAMES[target]);
+    await atomicWrite(outPath, content);
+    written.push(outPath);
+    status("+", success(`Exported ${target} \u2192 ${source(outPath)}`));
+  }
+  return { written, pageCount: computeReportedPageCount(pages, targets, marpSource) };
+}
+function resolveTargets(rawTarget) {
+  if (!rawTarget) return [...EXPORT_TARGETS];
+  if (!isValidTarget(rawTarget)) {
+    throw new Error(
+      `Unknown export target "${rawTarget}". Valid targets: ${EXPORT_TARGETS.join(", ")}`
+    );
+  }
+  return [rawTarget];
+}
+async function exportCommand(root, options) {
+  header("Exporting wiki");
+  const { written, pageCount } = await runExport(root, options);
+  status(
+    "\u2713",
+    success(`Done \u2014 ${pageCount} pages exported to ${written.length} file(s).`)
+  );
+}
+
 // src/commands/schema.ts
 import { existsSync as existsSync10 } from "fs";
-import { mkdir as mkdir6, writeFile as writeFile5 } from "fs/promises";
-import path24 from "path";
+import { mkdir as mkdir7, writeFile as writeFile5 } from "fs/promises";
+import path37 from "path";
 async function schemaInitCommand() {
   const root = process.cwd();
   const defaults = buildDefaultSchema();
@@ -3782,7 +5878,7 @@ async function schemaInitCommand() {
     status("!", warn(`Schema file already exists at ${targetPath}`));
     return;
   }
-  await mkdir6(path24.dirname(targetPath), { recursive: true });
+  await mkdir7(path37.dirname(targetPath), { recursive: true });
   const serializable = {
     version: defaults.version,
     defaultKind: defaults.defaultKind,
@@ -3838,10 +5934,17 @@ async function reviewShowCommand(id) {
       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 path25 from "path";
+import path38 from "path";
 
 // src/commands/review-helpers.ts
 async function runReviewUnderLock(id, underLock) {
@@ -3873,7 +5976,7 @@ async function approveUnderLock(root, id) {
     process.exitCode = 1;
     return;
   }
-  const pagePath = path25.join(root, CONCEPTS_DIR, `${candidate.slug}.md`);
+  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);
@@ -3933,7 +6036,7 @@ import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/tools.ts
-import path26 from "path";
+import path39 from "path";
 import { z } from "zod";
 
 // src/mcp/provider-check.ts
@@ -3941,7 +6044,8 @@ var PROVIDER_KEY_VARS = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY",
   ollama: null,
-  minimax: "MINIMAX_API_KEY"
+  minimax: "MINIMAX_API_KEY",
+  copilot: "GITHUB_TOKEN"
 };
 function ensureProviderAvailable() {
   const provider = process.env.LLMWIKI_PROVIDER ?? DEFAULT_PROVIDER;
@@ -4069,7 +6173,7 @@ async function pickSearchSlugs(root, question) {
     if (candidates.length > 0) return candidates.map((c) => c.slug);
   } catch {
   }
-  const indexContent = await safeReadFile(path26.join(root, INDEX_FILE));
+  const indexContent = await safeReadFile(path39.join(root, INDEX_FILE));
   const { pages } = await selectPages(question, indexContent);
   return pages;
 }
@@ -4128,8 +6232,8 @@ function registerStatusTool(server, root) {
   );
 }
 async function collectStatus(root) {
-  const concepts = await collectPageSummaries(path26.join(root, CONCEPTS_DIR));
-  const queries = await collectPageSummaries(path26.join(root, QUERIES_DIR));
+  const concepts = await collectPageSummaries(path39.join(root, CONCEPTS_DIR));
+  const queries = await collectPageSummaries(path39.join(root, QUERIES_DIR));
   const state = await readState(root);
   const changes = await detectChanges(root, state);
   const orphans = await findOrphanedSlugs(root);
@@ -4146,7 +6250,7 @@ async function collectStatus(root) {
   };
 }
 async function findOrphanedSlugs(root) {
-  const scanned = await scanWikiPages(path26.join(root, CONCEPTS_DIR));
+  const scanned = await scanWikiPages(path39.join(root, CONCEPTS_DIR));
   return scanned.filter(({ meta }) => meta.orphaned).map(({ slug }) => slug);
 }
 async function loadPageRecords(root, slugs) {
@@ -4159,7 +6263,7 @@ async function loadPageRecords(root, slugs) {
 }
 async function readPage(root, slug) {
   for (const dir of PAGE_DIRS2) {
-    const content = await safeReadFile(path26.join(root, dir, `${slug}.md`));
+    const content = await safeReadFile(path39.join(root, dir, `${slug}.md`));
     if (!content) continue;
     const { meta, body } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -4174,8 +6278,8 @@ async function readPage(root, slug) {
 }
 
 // src/mcp/resources.ts
-import path27 from "path";
-import { readdir as readdir9 } from "fs/promises";
+import path40 from "path";
+import { readdir as readdir12 } from "fs/promises";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 function jsonContent(uri, payload) {
   return {
@@ -4208,7 +6312,7 @@ function registerIndexResource(server, root) {
       mimeType: "text/markdown"
     },
     async (uri) => {
-      const content = await safeReadFile(path27.join(root, INDEX_FILE));
+      const content = await safeReadFile(path40.join(root, INDEX_FILE));
       return { contents: [markdownContent(uri, content)] };
     }
   );
@@ -4275,23 +6379,23 @@ function registerQueryResource(server, root) {
   );
 }
 async function listSources(root) {
-  const sourcesPath = path27.join(root, SOURCES_DIR);
+  const sourcesPath = path40.join(root, SOURCES_DIR);
   let files;
   try {
-    files = await readdir9(sourcesPath);
+    files = await readdir12(sourcesPath);
   } catch {
     return [];
   }
   const records = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path27.join(sourcesPath, file));
+    const content = await safeReadFile(path40.join(sourcesPath, file));
     const { meta } = parseFrontmatter(content);
     records.push({ filename: file, ...meta });
   }
   return records;
 }
 async function loadPageWithMeta(root, dir, slug) {
-  const filePath = path27.join(root, dir, `${slug}.md`);
+  const filePath = path40.join(root, dir, `${slug}.md`);
   const content = await safeReadFile(filePath);
   if (!content) {
     throw new Error(`Page not found: ${dir}/${slug}.md`);
@@ -4300,10 +6404,10 @@ async function loadPageWithMeta(root, dir, slug) {
   return { slug, meta, body: body.trim() };
 }
 async function listPagesUnder(root, dir, scheme) {
-  const pagesPath = path27.join(root, dir);
+  const pagesPath = path40.join(root, dir);
   let files;
   try {
-    files = await readdir9(pagesPath);
+    files = await readdir12(pagesPath);
   } catch {
     return { resources: [] };
   }
@@ -4327,8 +6431,8 @@ async function startMCPServer(options) {
 }
 
 // src/cli.ts
-var require2 = createRequire(import.meta.url);
-var { version } = require2("../package.json");
+var require3 = createRequire2(import.meta.url);
+var { version } = require3("../package.json");
 var program = new Command();
 program.name("llmwiki").description("The knowledge compiler \u2014 raw sources in, interlinked wiki out").version(version);
 program.command("ingest <source>").description("Ingest a URL or local file into sources/").action(async (source2) => {
@@ -4339,11 +6443,31 @@ program.command("ingest <source>").description("Ingest a URL or local file into
     process.exit(1);
   }
 });
+program.command("ingest-session <path>").description("Ingest a coding-agent session export (Claude, Codex, Cursor) into sources/").action(async (targetPath) => {
+  try {
+    await ingestSession(targetPath);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+program.command("view").description("Start a local read-only web viewer for the current wiki project").option("--port <port>", "Port to bind (default 0 \u2014 OS-assigned)").option("--host <host>", "Host to bind (requires --allow-lan; default 127.0.0.1)").option("--allow-lan", "Bind beyond loopback (requires --host); off by default for privacy").option("--open", "Open the viewer in the default browser after startup").action(async (options) => {
+  try {
+    await viewCommand(options);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
 program.command("compile").description("Compile sources/ into an interlinked wiki").option(
   "--review",
   "Write generated pages as review candidates under .llmwiki/candidates/ instead of mutating wiki/. Orphan-marking for deleted sources is deferred until the next non-review compile."
+).option(
+  "--lang <code>",
+  'Target language for generated wiki content (e.g. "Chinese", "ja", "zh-CN"). Equivalent to setting LLMWIKI_OUTPUT_LANG.'
 ).action(async (options) => {
   try {
+    applyLanguageOption(options.lang);
     requireProvider();
     await compileCommand({ review: options.review });
   } catch (err) {
@@ -4384,15 +6508,21 @@ reviewCommand.command("reject <id>").description("Reject a candidate and archive
     process.exit(1);
   }
 });
-program.command("query <question>").description("Ask a question against the wiki").option("--save", "Save the answer as a wiki page").option("--debug", "Print which pages and chunks were selected and their scores").action(async (question, options) => {
-  try {
-    requireProvider();
-    await queryCommand(process.cwd(), question, options);
-  } catch (err) {
-    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
-    process.exit(1);
+program.command("query <question>").description("Ask a question against the wiki").option("--save", "Save the answer as a wiki page").option("--debug", "Print which pages and chunks were selected and their scores").option(
+  "--lang <code>",
+  'Target language for the answer (e.g. "Chinese", "ja", "zh-CN"). Equivalent to setting LLMWIKI_OUTPUT_LANG.'
+).action(
+  async (question, options) => {
+    try {
+      applyLanguageOption(options.lang);
+      requireProvider();
+      await queryCommand(process.cwd(), question, options);
+    } catch (err) {
+      console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
   }
-});
+);
 program.command("watch").description("Watch sources/ and auto-recompile on changes").action(async () => {
   try {
     requireProvider();
@@ -4427,6 +6557,17 @@ schemaCmd.command("show").description("Print the resolved schema for this projec
     process.exit(1);
   }
 });
+program.command("export").description("Export wiki content to portable formats (llms.txt, JSON, GraphML, Marp, \u2026)").option("--target <name>", "Limit export to a single target format").option(
+  "--source <kind>",
+  "For marp target: which pages to include \u2014 concepts, queries, or all (default: all)"
+).action(async (options) => {
+  try {
+    await exportCommand(process.cwd(), options);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
 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 });
@@ -4435,11 +6576,17 @@ 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"
+  minimax: "MINIMAX_API_KEY",
+  copilot: "GITHUB_TOKEN"
 };
 function requireProvider() {
   const provider = process.env.LLMWIKI_PROVIDER ?? DEFAULT_PROVIDER;