llm-wiki-compiler 0.6.0 → 0.7.0

package/dist/cli.js

@@ -13,6 +13,7 @@ import { readFile as readFile7 } from "fs/promises";
 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([
@@ -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;
 }
@@ -138,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";
@@ -152,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;
@@ -1192,90 +1239,1387 @@ async function ingestDirectory(dirPath) {
       skipped++;
     }
   }
-  if (imported === 0) {
+  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 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 = 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 countCandidates(root) {
+  const candidates = await listCandidates(root);
+  return candidates.length;
+}
+async function deleteCandidate(root, id) {
+  const filePath = candidatePath(root, id);
+  if (!existsSync(filePath)) return false;
+  await unlink(filePath);
+  return true;
+}
+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/utils/state.ts
+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 = path20.join(root, STATE_FILE);
+  if (!existsSync2(filePath)) {
+    return emptyState();
+  }
+  try {
+    const raw = await readFile15(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    const bakPath = filePath + ".bak";
+    console.warn(`\u26A0 Corrupt state.json \u2014 backed up to ${bakPath}, starting fresh.`);
+    await copyFile(filePath, bakPath);
+    return emptyState();
+  }
+}
+async function writeState(root, state) {
+  const dir = path20.join(root, LLMWIKI_DIR);
+  await mkdir5(dir, { recursive: true });
+  const filePath = path20.join(root, STATE_FILE);
+  const tmpPath = filePath + ".tmp";
+  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);
+  state.sources[sourceFile] = entry;
+  await writeState(root, state);
+}
+async function removeSourceState(root, sourceFile) {
+  const state = await readState(root);
+  delete state.sources[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(
-      `No sessions imported from ${dirPath} (${skipped} file(s) skipped). Check that at least one file is in a supported session format.`
+      "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."
     );
   }
-  status(
-    "\u2192",
-    dim(`Imported ${imported} session(s), skipped ${skipped}.`)
-  );
+  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 };
 }
-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);
+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}`);
   }
-  status("\u2192", dim("Next: llmwiki compile"));
+  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 readFile18 } from "fs/promises";
-import path26 from "path";
-
-// src/utils/state.ts
-import { readFile as readFile11, writeFile as writeFile3, rename as rename2, mkdir as mkdir3, copyFile } from "fs/promises";
-import { existsSync } from "fs";
-import path13 from "path";
-function emptyState() {
-  return { version: 1, indexHash: "", sources: {} };
-}
-async function readState(root) {
-  const filePath = path13.join(root, STATE_FILE);
-  if (!existsSync(filePath)) {
-    return emptyState();
-  }
-  try {
-    const raw = await readFile11(filePath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    const bakPath = filePath + ".bak";
-    console.warn(`\u26A0 Corrupt state.json \u2014 backed up to ${bakPath}, starting fresh.`);
-    await copyFile(filePath, bakPath);
-    return emptyState();
-  }
-}
-async function writeState(root, state) {
-  const dir = path13.join(root, LLMWIKI_DIR);
-  await mkdir3(dir, { recursive: true });
-  const filePath = path13.join(root, STATE_FILE);
-  const tmpPath = filePath + ".tmp";
-  await writeFile3(tmpPath, JSON.stringify(state, null, 2), "utf-8");
-  await rename2(tmpPath, filePath);
-}
-async function updateSourceState(root, sourceFile, entry) {
-  const state = await readState(root);
-  state.sources[sourceFile] = entry;
-  await writeState(root, state);
-}
-async function removeSourceState(root, sourceFile) {
-  const state = await readState(root);
-  delete state.sources[sourceFile];
-  await writeState(root, state);
-}
+import { readFile as readFile23 } from "fs/promises";
+import path33 from "path";
 
 // src/compiler/source-state.ts
-import path15 from "path";
+import path23 from "path";
 
 // src/compiler/hasher.ts
 import { createHash as createHash2 } from "crypto";
-import { readFile as readFile12, readdir as readdir2 } from "fs/promises";
-import path14 from "path";
+import { readFile as readFile17, readdir as readdir5 } from "fs/promises";
+import path22 from "path";
 async function hashFile(filePath) {
-  const content = await readFile12(filePath, "utf-8");
+  const content = await readFile17(filePath, "utf-8");
   return createHash2("sha256").update(content).digest("hex");
 }
 async function detectChanges(root, prevState) {
-  const sourcesPath = path14.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);
@@ -1285,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 readdir2(sourcesPath);
+    const entries = await readdir5(sourcesPath);
     return entries.filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
 }
 async function classifyFile(root, file, prevState) {
-  const filePath = path14.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";
@@ -1317,7 +2661,7 @@ async function buildExtractionSourceStates(root, extractions) {
   return snapshot;
 }
 async function buildEntry(root, result, compiledAt) {
-  const filePath = path15.join(root, SOURCES_DIR, result.sourceFile);
+  const filePath = path23.join(root, SOURCES_DIR, result.sourceFile);
   const hash = await hashFile(filePath);
   return {
     hash,
@@ -1406,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) {
@@ -1463,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) {
@@ -1484,6 +2845,8 @@ function getProvider() {
       });
     case "minimax":
       return getMiniMaxProvider();
+    case "copilot":
+      return getCopilotProvider();
     default:
       throw new Error(`Unhandled provider: ${providerName}`);
   }
@@ -1504,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();
@@ -1555,8 +2927,8 @@ async function callClaude(options) {
 }
 
 // src/utils/lock.ts
-import { open, readFile as readFile13, unlink, mkdir as mkdir4 } from "fs/promises";
-import path16 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) {
@@ -1568,8 +2940,8 @@ function isProcessAlive(pid) {
   }
 }
 async function acquireLock(root) {
-  const lockPath = path16.join(root, LOCK_FILE);
-  await mkdir4(path16.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;
@@ -1593,7 +2965,7 @@ async function reclaimStaleLock(root, lockPath) {
       return false;
     }
     try {
-      await unlink(lockPath);
+      await unlink2(lockPath);
     } catch {
     }
     const acquired = await tryCreateLock(lockPath);
@@ -1603,7 +2975,7 @@ async function reclaimStaleLock(root, lockPath) {
     return acquired;
   } finally {
     try {
-      await unlink(reclaimPath);
+      await unlink2(reclaimPath);
     } catch {
     }
   }
@@ -1612,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;
@@ -1632,7 +3004,7 @@ async function tryCreateLock(lockPath) {
 }
 async function isLockStale(lockPath) {
   try {
-    const content = await readFile13(lockPath, "utf-8");
+    const content = await readFile18(lockPath, "utf-8");
     const pid = parseInt(content.trim(), 10);
     if (isNaN(pid)) return true;
     return !isProcessAlive(pid);
@@ -1641,9 +3013,9 @@ async function isLockStale(lockPath) {
   }
 }
 async function releaseLock(root) {
-  const lockPath = path16.join(root, LOCK_FILE);
+  const lockPath = path24.join(root, LOCK_FILE);
   try {
-    await unlink(lockPath);
+    await unlink2(lockPath);
   } catch {
   }
 }
@@ -1900,9 +3272,9 @@ function buildDefaultSchema() {
 }
 
 // src/schema/loader.ts
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile14 } from "fs/promises";
-import path17 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",
@@ -1913,8 +3285,8 @@ var SCHEMA_CANDIDATE_PATHS = [
 ];
 function findSchemaPath(root) {
   for (const candidate of SCHEMA_CANDIDATE_PATHS) {
-    const absolute = path17.join(root, candidate);
-    if (existsSync2(absolute)) return absolute;
+    const absolute = path25.join(root, candidate);
+    if (existsSync3(absolute)) return absolute;
   }
   return null;
 }
@@ -1966,12 +3338,12 @@ async function loadSchema(root) {
   const defaults = buildDefaultSchema();
   const schemaPath = findSchemaPath(root);
   if (!schemaPath) return defaults;
-  const raw = await readFile14(schemaPath, "utf-8");
+  const raw = await readFile19(schemaPath, "utf-8");
   const parsed = parseSchemaFile(schemaPath, raw);
   return applyOverrides(defaults, parsed, schemaPath);
 }
 function defaultSchemaInitPath(root) {
-  return path17.join(root, SCHEMA_CANDIDATE_PATHS[0]);
+  return path25.join(root, SCHEMA_CANDIDATE_PATHS[0]);
 }
 
 // src/schema/helpers.ts
@@ -2143,7 +3515,7 @@ async function freezeFailedExtractions(root, results, frozenSlugs) {
 }
 
 // src/compiler/orphan.ts
-import path18 from "path";
+import path26 from "path";
 async function markOrphaned(root, sourceFile, state) {
   const sourceEntry = state.sources[sourceFile];
   if (!sourceEntry) return;
@@ -2169,7 +3541,7 @@ async function orphanUnownedFrozenPages(root, frozenSlugs) {
   }
 }
 async function orphanPage(root, slug, reason) {
-  const pagePath = path18.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);
@@ -2180,18 +3552,18 @@ async function orphanPage(root, slug, reason) {
 }
 
 // src/compiler/resolver.ts
-import { readdir as readdir3, readFile as readFile15 } from "fs/promises";
-import path19 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 = path19.join(root, CONCEPTS_DIR);
-  if (!existsSync3(conceptsDir)) return [];
-  const files = await readdir3(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 = path19.join(conceptsDir, file);
-    const content = await readFile15(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({
@@ -2277,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 readFile15(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) {
@@ -2289,7 +3661,7 @@ async function resolveInboundLinks(titleIndex, newSlugs) {
   return count;
 }
 async function linkPage(page, titleIndex) {
-  const content = await readFile15(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;
@@ -2299,18 +3671,18 @@ async function linkPage(page, titleIndex) {
 }
 
 // src/compiler/indexgen.ts
-import { readdir as readdir4 } from "fs/promises";
-import path20 from "path";
+import { readdir as readdir7 } from "fs/promises";
+import path28 from "path";
 async function generateIndex(root) {
   status("*", info("Generating index..."));
-  const conceptsPath = path20.join(root, CONCEPTS_DIR);
-  const queriesPath = path20.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 = path20.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.`));
@@ -2318,13 +3690,13 @@ async function generateIndex(root) {
 async function scanWikiPages(dirPath) {
   let files;
   try {
-    files = await readdir4(dirPath);
+    files = await readdir7(dirPath);
   } catch {
     return [];
   }
   const scanned = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path20.join(dirPath, file));
+    const content = await safeReadFile(path28.join(dirPath, file));
     const { meta } = parseFrontmatter(content);
     scanned.push({ slug: file.replace(/\.md$/, ""), meta });
   }
@@ -2396,8 +3768,8 @@ function warnTruncation(concept, totalRaw, sourceCount, perSource, budget) {
 }
 
 // src/compiler/obsidian.ts
-import { readdir as readdir5 } from "fs/promises";
-import path21 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) {
@@ -2439,23 +3811,23 @@ function generateAbbreviation(title) {
   return abbreviation;
 }
 async function generateMOC(root) {
-  const conceptsPath = path21.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(path21.join(root, MOC_FILE), content);
+  await atomicWrite(path29.join(root, MOC_FILE), content);
 }
 async function loadConceptPages(conceptsPath) {
   let files;
   try {
-    files = await readdir5(conceptsPath);
+    files = await readdir8(conceptsPath);
   } catch {
     return [];
   }
   const pages = [];
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const content = await safeReadFile(path21.join(conceptsPath, file));
+    const content = await safeReadFile(path29.join(conceptsPath, file));
     if (!content) continue;
     const { meta } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -2506,9 +3878,9 @@ function buildMOCContent(tagGroups) {
 }
 
 // src/utils/embeddings.ts
-import { readFile as readFile16, readdir as readdir6 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import path22 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 createHash3 } from "crypto";
@@ -2673,13 +4045,13 @@ function findTopKChunks(queryVec, chunks, k) {
   return scored.slice(0, k);
 }
 async function readEmbeddingStore(root) {
-  const filePath = path22.join(root, EMBEDDINGS_FILE);
-  if (!existsSync4(filePath)) return null;
-  const raw = await readFile16(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 = path22.join(root, EMBEDDINGS_FILE);
+  const filePath = path30.join(root, EMBEDDINGS_FILE);
   await atomicWrite(filePath, JSON.stringify(store, null, 2));
 }
 async function findRelevantPages(root, question) {
@@ -2711,10 +4083,10 @@ async function loadActiveStore(root, hasContent) {
 async function collectPageRecords(root) {
   const records = [];
   for (const dir of [CONCEPTS_DIR, QUERIES_DIR]) {
-    const absDir = path22.join(root, dir);
+    const absDir = path30.join(root, dir);
     let files;
     try {
-      files = await readdir6(absDir);
+      files = await readdir9(absDir);
     } catch {
       continue;
     }
@@ -2726,7 +4098,7 @@ async function collectPageRecords(root) {
   return records;
 }
 async function readPageRecord(absDir, file) {
-  const content = await safeReadFile(path22.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 {
@@ -2887,115 +4259,10 @@ function shouldRunEmbedding(modelChanged, toEmbed, previousEntries, previousChun
   return false;
 }
 
-// src/compiler/candidates.ts
-import { readdir as readdir7, rename as rename3, unlink as unlink2, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import path23 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 path23.join(root, CANDIDATES_DIR, `${id}${CANDIDATE_EXT}`);
-}
-function archivePath(root, id) {
-  return path23.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 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 = path23.join(root, CANDIDATES_DIR);
-  if (!existsSync5(dir)) return [];
-  const entries = await readdir7(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(path23.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 readdir8, readFile as readFile17 } from "fs/promises";
+import { readdir as readdir10, readFile as readFile22 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import path24 from "path";
+import path31 from "path";
 var MIN_BODY_LENGTH = 50;
 var WIKILINK_PATTERN2 = /\[\[([^\]]+)\]\]/g;
 var CITATION_PATTERN = /\^\[([^\]]+)\]/g;
@@ -3012,26 +4279,26 @@ function findMatchesInContent(content, pattern) {
 }
 async function readMarkdownFiles(dirPath) {
   if (!existsSync6(dirPath)) return [];
-  const entries = await readdir8(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 = path24.join(dirPath, fileName);
-      const content = await readFile17(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(path24.join(root, CONCEPTS_DIR));
-  const queryPages = await readMarkdownFiles(path24.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 = path24.basename(page.filePath, ".md");
+    const baseName = path31.basename(page.filePath, ".md");
     slugs.add(baseName.toLowerCase());
   }
   return slugs;
@@ -3254,7 +4521,7 @@ function countLines(content) {
 }
 async function checkBrokenCitations(root) {
   const pages = await collectAllPages(root);
-  const sourcesDir = path24.join(root, SOURCES_DIR);
+  const sourcesDir = path31.join(root, SOURCES_DIR);
   const results = [];
   const lineCountCache = /* @__PURE__ */ new Map();
   for (const page of pages) {
@@ -3280,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 = path24.join(sourcesDir, filename);
+    const citedPath = path31.join(sourcesDir, filename);
     if (!existsSync6(citedPath)) {
       out.push({
         rule: "broken-citation",
@@ -3338,8 +4605,8 @@ function checkPageMalformedCitations(content, filePath) {
 }
 
 // src/compiler/page-renderer.ts
-import { readdir as readdir9 } from "fs/promises";
-import path25 from "path";
+import { readdir as readdir11 } from "fs/promises";
+import path32 from "path";
 
 // src/compiler/provenance.ts
 function addProvenanceMeta(fields, concept) {
@@ -3366,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 = path25.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(
@@ -3405,17 +4672,17 @@ function buildMergedFrontmatter(entry, existingPage, schema) {
   return buildFrontmatter(frontmatterFields);
 }
 async function loadRelatedPages(root, excludeSlug) {
-  const conceptsPath = path25.join(root, CONCEPTS_DIR);
+  const conceptsPath = path32.join(root, CONCEPTS_DIR);
   let files;
   try {
-    files = await readdir9(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(path25.join(conceptsPath, f));
+    const content = await safeReadFile(path32.join(conceptsPath, f));
     if (!content) continue;
     const { meta } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -3628,9 +4895,9 @@ function printChangesSummary(changes) {
 }
 async function extractForSource(root, sourceFile) {
   status("*", info(`Extracting: ${sourceFile}`));
-  const sourcePath = path26.join(root, SOURCES_DIR, sourceFile);
-  const sourceContent = await readFile18(sourcePath, "utf-8");
-  const existingIndex = await safeReadFile(path26.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(", ");
@@ -3696,7 +4963,7 @@ async function generateMergedPage(root, entry, schema, options, sourceStates) {
   if (options.review) {
     return await persistReviewCandidate(root, entry, fullPage, sourceStates, schema);
   }
-  const pagePath = path26.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 };
 }
@@ -3726,7 +4993,7 @@ async function collectCandidateProvenanceViolations(root, fullPage, virtualPath)
   const broken = await checkPageBrokenCitations(
     fullPage,
     virtualPath,
-    path26.join(root, SOURCES_DIR)
+    path33.join(root, SOURCES_DIR)
   );
   return [...malformed, ...broken];
 }
@@ -3743,7 +5010,7 @@ async function generateSeedPages(root, schema, generation) {
 }
 async function generateSingleSeedPage(root, schema, seed) {
   const slug = slugify(seed.title);
-  const pagePath = path26.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);
@@ -3776,7 +5043,7 @@ async function loadSeedRelatedPages(root, slugs) {
   if (slugs.length === 0) return "";
   const contents = [];
   for (const slug of slugs) {
-    const pagePath = path26.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);
   }
@@ -3831,7 +5098,7 @@ async function compileCommand(options = {}) {
 
 // src/commands/query.ts
 import { existsSync as existsSync8 } from "fs";
-import path27 from "path";
+import path34 from "path";
 var PAGE_DIRS = [CONCEPTS_DIR, QUERIES_DIR];
 var PAGE_SELECTION_TOOL = {
   name: "select_pages",
@@ -3888,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(path27.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: [] };
 }
@@ -3980,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(path27.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;
@@ -4031,7 +5298,7 @@ function summarizeAnswer(answer) {
 }
 async function saveQueryPage(root, question, answer) {
   const slug = slugify(question);
-  const filePath = path27.join(root, QUERIES_DIR, `${slug}.md`);
+  const filePath = path34.join(root, QUERIES_DIR, `${slug}.md`);
   const frontmatter = buildFrontmatter({
     title: question,
     summary: summarizeAnswer(answer),
@@ -4057,7 +5324,7 @@ ${answer}
   return slug;
 }
 async function generateAnswer(root, question, options = {}) {
-  if (!existsSync8(path27.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));
@@ -4085,7 +5352,7 @@ function buildEmptyResult(selection) {
   };
 }
 async function queryCommand(root, question, options) {
-  if (!existsSync8(path27.join(root, INDEX_FILE))) {
+  if (!existsSync8(path34.join(root, INDEX_FILE))) {
     status("!", error("Wiki index not found. Run `llmwiki compile` first."));
     return;
   }
@@ -4136,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 path28 from "path";
+import path35 from "path";
 var DEBOUNCE_MS = 500;
 async function watchCommand() {
-  const sourcesPath = path28.resolve(SOURCES_DIR);
+  const sourcesPath = path35.resolve(SOURCES_DIR);
   if (!existsSync9(sourcesPath)) {
     status(
       "!",
@@ -4174,7 +5441,7 @@ async function watchCommand() {
   const scheduleCompile = (eventPath, event) => {
     status(
       "~",
-      dim(`${event}: ${path28.basename(eventPath)}`)
+      dim(`${event}: ${path35.basename(eventPath)}`)
     );
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(triggerCompile, DEBOUNCE_MS);
@@ -4253,75 +5520,38 @@ 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 path30 from "path";
+import path36 from "path";
 import { createRequire } from "module";
 
 // src/export/collect.ts
-import { readdir as readdir10, readFile as readFile19 } from "fs/promises";
-import path29 from "path";
-var WIKILINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
-function extractWikilinkSlugs(body) {
-  const slugs = /* @__PURE__ */ new Set();
-  let match;
-  while ((match = WIKILINK_RE.exec(body)) !== null) {
-    slugs.add(slugify(match[1].trim()));
-  }
-  return [...slugs];
-}
-async function parsePageFile(filePath, slug, pageDirectory) {
-  let raw;
-  try {
-    raw = await readFile19(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-  const { meta, body } = parseFrontmatter(raw);
-  if (!meta.title || typeof meta.title !== "string") return null;
-  if (meta.orphaned === true) return null;
+function toExportPage(raw) {
+  const meta = raw.frontmatter;
   return {
-    title: meta.title,
-    slug,
-    pageDirectory,
+    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(body),
-    body
+    links: extractWikilinkSlugs(raw.body),
+    body: raw.body
   };
 }
-async function collectFromDir(dirPath, pageDirectory) {
-  let files;
-  try {
-    files = await readdir10(dirPath);
-  } catch {
-    return [];
-  }
-  const pages = [];
-  for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const slug = file.replace(/\.md$/, "");
-    const page = await parsePageFile(path29.join(dirPath, file), slug, pageDirectory);
-    if (page) pages.push(page);
-  }
-  return pages;
-}
 async function collectExportPages(root) {
-  const conceptsPath = path29.join(root, CONCEPTS_DIR);
-  const queriesPath = path29.join(root, QUERIES_DIR);
-  const [concepts, queries] = await Promise.all([
-    collectFromDir(conceptsPath, "concepts"),
-    collectFromDir(queriesPath, "queries")
-  ]);
-  const all = [...concepts, ...queries];
-  all.sort((a, b) => a.title.localeCompare(b.title));
-  return all;
+  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
@@ -4559,7 +5789,7 @@ var TARGET_FILENAMES = {
 };
 function resolveProjectTitle(root) {
   try {
-    const pkg = require2(path30.join(root, "package.json"));
+    const pkg = require2(path36.join(root, "package.json"));
     return typeof pkg.name === "string" ? pkg.name : "Knowledge Wiki";
   } catch {
     return "Knowledge Wiki";
@@ -4611,7 +5841,7 @@ async function runExport(root, options = {}) {
   const written = [];
   for (const target of targets) {
     const content = buildContent(target, pages, projectTitle, marpSource);
-    const outPath = path30.join(root, EXPORT_DIR, TARGET_FILENAMES[target]);
+    const outPath = path36.join(root, EXPORT_DIR, TARGET_FILENAMES[target]);
     await atomicWrite(outPath, content);
     written.push(outPath);
     status("+", success(`Exported ${target} \u2192 ${source(outPath)}`));
@@ -4638,8 +5868,8 @@ async function exportCommand(root, options) {
 
 // src/commands/schema.ts
 import { existsSync as existsSync10 } from "fs";
-import { mkdir as mkdir6, writeFile as writeFile5 } from "fs/promises";
-import path31 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();
@@ -4648,7 +5878,7 @@ async function schemaInitCommand() {
     status("!", warn(`Schema file already exists at ${targetPath}`));
     return;
   }
-  await mkdir6(path31.dirname(targetPath), { recursive: true });
+  await mkdir7(path37.dirname(targetPath), { recursive: true });
   const serializable = {
     version: defaults.version,
     defaultKind: defaults.defaultKind,
@@ -4714,7 +5944,7 @@ async function reviewShowCommand(id) {
 }
 
 // src/commands/review-approve.ts
-import path32 from "path";
+import path38 from "path";
 
 // src/commands/review-helpers.ts
 async function runReviewUnderLock(id, underLock) {
@@ -4746,7 +5976,7 @@ async function approveUnderLock(root, id) {
     process.exitCode = 1;
     return;
   }
-  const pagePath = path32.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);
@@ -4806,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 path33 from "path";
+import path39 from "path";
 import { z } from "zod";
 
 // src/mcp/provider-check.ts
@@ -4814,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;
@@ -4942,7 +6173,7 @@ async function pickSearchSlugs(root, question) {
     if (candidates.length > 0) return candidates.map((c) => c.slug);
   } catch {
   }
-  const indexContent = await safeReadFile(path33.join(root, INDEX_FILE));
+  const indexContent = await safeReadFile(path39.join(root, INDEX_FILE));
   const { pages } = await selectPages(question, indexContent);
   return pages;
 }
@@ -5001,8 +6232,8 @@ function registerStatusTool(server, root) {
   );
 }
 async function collectStatus(root) {
-  const concepts = await collectPageSummaries(path33.join(root, CONCEPTS_DIR));
-  const queries = await collectPageSummaries(path33.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);
@@ -5019,7 +6250,7 @@ async function collectStatus(root) {
   };
 }
 async function findOrphanedSlugs(root) {
-  const scanned = await scanWikiPages(path33.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) {
@@ -5032,7 +6263,7 @@ async function loadPageRecords(root, slugs) {
 }
 async function readPage(root, slug) {
   for (const dir of PAGE_DIRS2) {
-    const content = await safeReadFile(path33.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;
@@ -5047,8 +6278,8 @@ async function readPage(root, slug) {
 }
 
 // src/mcp/resources.ts
-import path34 from "path";
-import { readdir as readdir11 } 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 {
@@ -5081,7 +6312,7 @@ function registerIndexResource(server, root) {
       mimeType: "text/markdown"
     },
     async (uri) => {
-      const content = await safeReadFile(path34.join(root, INDEX_FILE));
+      const content = await safeReadFile(path40.join(root, INDEX_FILE));
       return { contents: [markdownContent(uri, content)] };
     }
   );
@@ -5148,23 +6379,23 @@ function registerQueryResource(server, root) {
   );
 }
 async function listSources(root) {
-  const sourcesPath = path34.join(root, SOURCES_DIR);
+  const sourcesPath = path40.join(root, SOURCES_DIR);
   let files;
   try {
-    files = await readdir11(sourcesPath);
+    files = await readdir12(sourcesPath);
   } catch {
     return [];
   }
   const records = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path34.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 = path34.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`);
@@ -5173,10 +6404,10 @@ async function loadPageWithMeta(root, dir, slug) {
   return { slug, meta, body: body.trim() };
 }
 async function listPagesUnder(root, dir, scheme) {
-  const pagesPath = path34.join(root, dir);
+  const pagesPath = path40.join(root, dir);
   let files;
   try {
-    files = await readdir11(pagesPath);
+    files = await readdir12(pagesPath);
   } catch {
     return { resources: [] };
   }
@@ -5220,6 +6451,14 @@ program.command("ingest-session <path>").description("Ingest a coding-agent sess
     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."
@@ -5346,7 +6585,8 @@ 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;