llm-wiki-compiler 0.10.0 → 0.11.0

package/dist/cli.js

@@ -219,6 +219,7 @@ 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 EXPORT_DIR = "dist/exports";
 var SOURCES_DIR = "sources";
 var CONCEPTS_DIR = "wiki/concepts";
 var QUERIES_DIR = "wiki/queries";
@@ -281,6 +282,25 @@ async function confinedRegularFile(dir, name) {
   if (real === null || !isInsideDir(real, dir)) return null;
   return real;
 }
+async function confineUnderRoot(target, root, opts) {
+  const realRoot = await safeRealpath(root) ?? path2.resolve(root);
+  const abs = path2.normalize(path2.resolve(realRoot, target));
+  if (!isInsideDir(abs, realRoot)) throw new Error(`path escapes project root: ${target}`);
+  if (opts.mustExist) {
+    const real = await safeRealpath(abs);
+    if (real === null || !isInsideDir(real, realRoot)) throw new Error(`path escapes project root: ${target}`);
+    return real;
+  }
+  for (let cur = abs; ; cur = path2.dirname(cur)) {
+    const real = await safeRealpath(cur);
+    if (real !== null) {
+      if (!isInsideDir(real, realRoot)) throw new Error(`path escapes project root: ${target}`);
+      break;
+    }
+    if (path2.dirname(cur) === cur) break;
+  }
+  return abs;
+}
 
 // src/viewer/path-safety.ts
 import path3 from "path";
@@ -429,6 +449,9 @@ function source(text) {
 }
 var quietMode = false;
 var quietScope = new AsyncLocalStorage();
+function withQuiet(fn) {
+  return quietScope.run(true, fn);
+}
 function isQuiet() {
   return quietScope.getStore() ?? quietMode;
 }
@@ -7728,7 +7751,7 @@ async function evalJudgementsCommand(options = {}) {
 }
 
 // src/commands/export.ts
-import path53 from "path";
+import path55 from "path";
 import { createRequire } from "module";
 
 // src/export/collect.ts
@@ -8198,9 +8221,12 @@ ${pageToSlide(p)}`);
   return [frontmatter, titleSlide, ...slides, ""].join("\n\n");
 }
 
+// src/export/okf/run.ts
+import path54 from "path";
+
 // src/export/okf/bundle.ts
-import { mkdir as mkdir9, copyFile as copyFile2, rm, readFile as readFile29 } from "fs/promises";
-import path52 from "path";
+import { mkdir as mkdir9, copyFile as copyFile2, rm, readFile as readFile29, readdir as readdir16, lstat as lstat4 } from "fs/promises";
+import path53 from "path";
 
 // src/export/okf/mapping.ts
 import { createHash as createHash7 } from "crypto";
@@ -8268,7 +8294,7 @@ function mapPageToOkfFrontmatter(page) {
   return fm;
 }
 var WIKILINK = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
-var OKF_LINK = /\[([^\]]+)\]\(\/(concepts|queries)\/([^)]+?)\.md\)/g;
+var OKF_LINK = /\[([^\]]+)\]\(\/([^)]+?)\.md\)/g;
 var FENCE = /(```[\s\S]*?```|~~~[\s\S]*?~~~)/g;
 function wikilinksToOkf(body, resolve) {
   return body.split(FENCE).map(
@@ -8276,14 +8302,15 @@ function wikilinksToOkf(body, resolve) {
       const slug = slugify(rawSlug);
       const target = resolve(slug);
       if (!target) return match;
-      return `[${disp ?? target.title}](/${target.dir}/${slug}.md)`;
+      return `[${disp ?? target.title}](/${target.path})`;
     })
   ).join("");
 }
-function okfLinksToWikilinks(body, titleOf) {
-  return body.replace(OKF_LINK, (_m, text, _dir, slug) => {
-    const title = titleOf(slug);
-    return title !== null && text === title ? `[[${slug}]]` : `[[${slug}|${text}]]`;
+function okfLinksToWikilinks(body, resolveLink) {
+  return body.replace(OKF_LINK, (match, text, linkPath) => {
+    const r = resolveLink(linkPath);
+    if (!r) return match;
+    return r.title === text ? `[[${r.slug}]]` : `[[${r.slug}|${text}]]`;
   });
 }
 
@@ -8315,8 +8342,8 @@ ${rewritten}${citations}`;
 }
 
 // src/export/okf/index-log.ts
-function buildOkfIndex(pages) {
-  const entry = (p) => `* [${p.title}](/${p.pageDirectory}/${p.slug}.md) - ${p.summary}`;
+function buildOkfIndex(pages, paths) {
+  const entry = (p) => `* [${p.title}](/${paths.get(p)}) - ${p.summary}`;
   const concepts = pages.filter((p) => p.pageDirectory === "concepts").map(entry);
   const queries = pages.filter((p) => p.pageDirectory === "queries").map(entry);
   const sections = [];
@@ -8379,71 +8406,178 @@ async function resolveReferences(root, pages) {
   return resolved;
 }
 
+// src/export/okf/output-paths.ts
+import path52 from "path";
+function slugPath(p) {
+  return `${p.pageDirectory}/${p.slug}.md`;
+}
+function isSafeOkfPath(okfPath, realOut) {
+  if (typeof okfPath !== "string" || okfPath.length === 0) return false;
+  if (path52.isAbsolute(okfPath)) return false;
+  if (!/^[A-Za-z0-9._/-]+$/.test(okfPath)) return false;
+  const segments = okfPath.split(/[/\\]+/);
+  if (segments.includes("..") || segments.includes(".")) return false;
+  if (!okfPath.endsWith(".md")) return false;
+  if (okfPath === "index.md" || okfPath === "log.md") return false;
+  if (okfPath === "references" || okfPath.startsWith("references/")) return false;
+  return isInsideDir(path52.normalize(path52.join(realOut, okfPath)), realOut);
+}
+function compareForeign(a, b) {
+  const ap = a.xOkf.okfPath, bp = b.xOkf.okfPath;
+  if (ap !== bp) return ap < bp ? -1 : 1;
+  if (a.pageDirectory !== b.pageDirectory) return a.pageDirectory < b.pageDirectory ? -1 : 1;
+  if (a.slug !== b.slug) return a.slug < b.slug ? -1 : 1;
+  return 0;
+}
+function resolveOutputPaths(pages, realOut) {
+  const owner = /* @__PURE__ */ new Map();
+  for (const p of pages) owner.set(slugPath(p), p);
+  const paths = /* @__PURE__ */ new Map();
+  const warnings = [];
+  const used = /* @__PURE__ */ new Set();
+  const foreign = pages.filter((p) => typeof p.xOkf?.okfPath === "string").sort(compareForeign);
+  const native = pages.filter((p) => typeof p.xOkf?.okfPath !== "string");
+  for (const p of foreign) {
+    const okfPath = p.xOkf.okfPath;
+    const ownerOfOkf = owner.get(okfPath);
+    const usable = isSafeOkfPath(okfPath, realOut) && !used.has(okfPath) && (ownerOfOkf === void 0 || ownerOfOkf === p);
+    if (usable) {
+      paths.set(p, okfPath);
+      used.add(okfPath);
+    } else {
+      const sp = slugPath(p);
+      paths.set(p, sp);
+      used.add(sp);
+      warnings.push(`OKF export: ${okfPath} not restorable (unsafe or collides); using ${sp}`);
+    }
+  }
+  for (const p of native) {
+    const sp = slugPath(p);
+    paths.set(p, sp);
+    used.add(sp);
+  }
+  return { paths, warnings };
+}
+
 // src/export/okf/bundle.ts
-function makeResolver(pages) {
-  const map = new Map(
-    pages.map((p) => [p.slug, { dir: p.pageDirectory, title: p.title }])
-  );
+var IGNORED_DIR_ENTRIES = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db"]);
+function makeResolver(pages, paths) {
+  const map = new Map(pages.map((p) => [p.slug, { path: paths.get(p), title: p.title }]));
   return (slug) => map.get(slug) ?? null;
 }
 async function writeConfined(out, rel, content) {
-  const normalized = path52.normalize(path52.join(out, rel));
-  if (!isInsideDir(normalized, out)) throw new Error(`OKF write escapes bundle: ${rel}`);
-  await atomicWrite(normalized, content);
-  return normalized;
+  const abs = await confineUnderRoot(rel, out, { mustExist: false });
+  await atomicWrite(abs, content);
+  return abs;
 }
-async function clearOkfManaged(realOut) {
-  for (const rel of ["concepts", "queries", "references", "index.md", "log.md"]) {
-    await rm(path52.join(realOut, rel), { recursive: true, force: true });
+async function lexists(p) {
+  try {
+    await lstat4(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveRealTarget(p) {
+  let cur = path53.resolve(p);
+  const suffix = [];
+  for (; ; ) {
+    const real = await safeRealpath(cur);
+    if (real) return suffix.length ? path53.join(real, ...suffix.reverse()) : real;
+    const parent = path53.dirname(cur);
+    if (parent === cur) return path53.resolve(p);
+    suffix.push(path53.basename(cur));
+    cur = parent;
   }
 }
+async function assertSafeBundleTarget(out, root) {
+  const realRoot = await safeRealpath(root) ?? path53.resolve(root);
+  const target = await resolveRealTarget(out);
+  if (target === path53.parse(target).root) throw new Error("OKF export: refusing to export to the filesystem root");
+  if (target === realRoot) throw new Error("OKF export: refusing to export to the project root");
+  if (isInsideDir(target, path53.join(realRoot, ".git"))) throw new Error("OKF export: refusing to export inside .git");
+}
+async function assertNoTopLevelGit(realOut) {
+  if (await lexists(path53.join(realOut, ".git"))) throw new Error("OKF export: refusing to export to a directory containing .git");
+}
+async function isRecognizedBundle(realOut) {
+  const idx = path53.join(realOut, "index.md");
+  try {
+    if (!(await lstat4(idx)).isFile()) return false;
+  } catch {
+    return false;
+  }
+  const { meta } = parseFrontmatterStatus(await readFile29(idx, "utf-8"));
+  return typeof meta.okf_version !== "undefined";
+}
+async function assertNoNestedGit(realOut) {
+  for (const e of await readdir16(realOut, { withFileTypes: true })) {
+    if (e.name === ".git") throw new Error(`OKF export: refusing to clear ${realOut} \u2014 it contains a nested .git`);
+    if (e.isDirectory()) await assertNoNestedGit(path53.join(realOut, e.name));
+  }
+}
+async function clearContents(realOut) {
+  for (const name of await readdir16(realOut)) await rm(path53.join(realOut, name), { recursive: true, force: true });
+}
 async function buildLog(root, pageCount) {
   const fallback = [{ date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), action: "Export", text: `${pageCount} doc(s)` }];
-  const llmwikiLog = await readFile29(path52.join(root, "log.md"), "utf-8").catch(() => null);
+  const llmwikiLog = await readFile29(path53.join(root, "log.md"), "utf-8").catch(() => null);
   const parsed = llmwikiLog ? parseLlmwikiLog(llmwikiLog) : [];
   return buildOkfLog(parsed.length ? parsed : fallback);
 }
 async function copyResolvedReferences(refs, realOut) {
   const written = [];
   for (const { srcAbs, destName } of refs.values()) {
-    const dest = path52.join(realOut, "references", destName);
-    if (!isInsideDir(path52.normalize(dest), realOut)) continue;
-    await mkdir9(path52.dirname(dest), { recursive: true });
+    const dest = await confineUnderRoot(path53.join("references", destName), realOut, { mustExist: false });
+    await mkdir9(path53.dirname(dest), { recursive: true });
     await copyFile2(srcAbs, dest);
     written.push(dest);
   }
   return written;
 }
-function reportSkippedReferences(pages, refs) {
+function reportSkippedReferences(pages, refs, onWarn) {
   const skipped = collectReferenceFiles(pages).filter((f) => !refs.has(f));
   if (skipped.length === 0) return;
-  status(
-    "!",
-    warn(`OKF export: ${skipped.length} cited source(s) not bundled (missing or outside sources/)`)
-  );
+  onWarn(`OKF export: ${skipped.length} cited source(s) not bundled (missing or outside sources/)`);
 }
-async function buildOkfBundle(root, pages, out) {
+async function buildOkfBundle(root, pages, out, onWarn = (m) => status("!", warn(m))) {
+  await assertSafeBundleTarget(out, root);
   await mkdir9(out, { recursive: true });
-  const realOut = await safeRealpath(out) ?? path52.normalize(out);
-  await clearOkfManaged(realOut);
-  const resolve = makeResolver(pages);
+  const realOut = await safeRealpath(out) ?? path53.normalize(out);
+  await assertNoTopLevelGit(realOut);
+  const empty = (await readdir16(realOut)).filter((e) => !IGNORED_DIR_ENTRIES.has(e)).length === 0;
+  const bundle = empty ? false : await isRecognizedBundle(realOut);
+  if (!empty && !bundle) throw new Error(`OKF export: ${out} is not empty and not an OKF bundle; export into a fresh directory or an existing OKF bundle.`);
+  if (bundle) {
+    await assertNoNestedGit(realOut);
+    await clearContents(realOut);
+  }
+  const { paths, warnings: pathWarnings } = resolveOutputPaths(pages, realOut);
+  const resolve = makeResolver(pages, paths);
   const refs = await resolveReferences(root, pages);
   const refName = (file) => refs.get(file)?.destName ?? null;
   const written = [];
-  written.push(await writeConfined(realOut, "index.md", buildOkfIndex(pages)));
+  written.push(await writeConfined(realOut, "index.md", buildOkfIndex(pages, paths)));
   for (const p of pages) {
-    const docRel = `${p.pageDirectory}/${p.slug}.md`;
-    const docAbs = path52.normalize(path52.join(realOut, docRel));
-    const pageDir = path52.join(realOut, p.pageDirectory);
-    if (!isInsideDir(docAbs, pageDir)) throw new Error(`OKF page slug escapes its directory: ${p.slug}`);
+    const docRel = paths.get(p);
     written.push(await writeConfined(realOut, docRel, renderOkfDoc(p, resolve, refName)));
   }
   written.push(...await copyResolvedReferences(refs, realOut));
   written.push(await writeConfined(realOut, "log.md", await buildLog(root, pages.length)));
-  reportSkippedReferences(pages, refs);
+  reportSkippedReferences(pages, refs, onWarn);
+  for (const w of pathWarnings) onWarn(w);
   return written;
 }
 
+// src/export/okf/run.ts
+async function runOkfExport(root, opts = {}) {
+  const outDir = opts.out ?? path54.join(root, EXPORT_DIR, "okf");
+  const pages = await collectExportPages(root);
+  const warnings = [];
+  const writtenPaths = await buildOkfBundle(root, pages, outDir, (m) => warnings.push(m));
+  return { outDir, writtenPaths, warnings };
+}
+
 // src/export/types.ts
 var MARP_SOURCES = ["concepts", "queries", "all"];
 var EXPORT_TARGETS = [
@@ -8466,7 +8600,6 @@ var DEFAULT_EXPORT_TARGETS = [
 
 // src/commands/export.ts
 var require2 = createRequire(import.meta.url);
-var EXPORT_DIR = "dist/exports";
 var TARGET_FILENAMES = {
   "llms-txt": "llms.txt",
   "llms-full-txt": "llms-full.txt",
@@ -8480,7 +8613,7 @@ var TARGET_FILENAMES = {
 };
 function resolveProjectTitle(root) {
   try {
-    const pkg = require2(path53.join(root, "package.json"));
+    const pkg = require2(path55.join(root, "package.json"));
     return typeof pkg.name === "string" ? pkg.name : "Knowledge Wiki";
   } catch {
     return "Knowledge Wiki";
@@ -8536,14 +8669,14 @@ async function runExport(root, options = {}) {
   const written = [];
   for (const target of targets) {
     if (target === "okf") {
-      const outDir = options.out ?? path53.join(root, EXPORT_DIR, "okf");
-      const writtenPaths = await buildOkfBundle(root, pages, outDir);
+      const { outDir, writtenPaths, warnings } = await runOkfExport(root, { out: options.out });
       written.push(...writtenPaths);
+      for (const w of warnings) status("!", warn(w));
       status("+", success(`Exported okf bundle \u2192 ${source(outDir)}`));
       continue;
     }
     const content = buildContent({ target, pages, projectTitle, marpSource, projectId });
-    const outPath = path53.join(root, EXPORT_DIR, TARGET_FILENAMES[target]);
+    const outPath = path55.join(root, EXPORT_DIR, TARGET_FILENAMES[target]);
     await atomicWrite(outPath, content);
     written.push(outPath);
     status("+", success(`Exported ${target} \u2192 ${source(outPath)}`));
@@ -8568,15 +8701,15 @@ async function exportCommand(root, options) {
   );
 }
 
-// src/commands/import.ts
-import path57 from "path";
+// src/import/run.ts
+import path59 from "path";
 
 // src/import/okf-import.ts
-import path56 from "path";
+import path58 from "path";
 
 // src/import/okf-read.ts
-import { readdir as readdir16, readFile as readFile30, stat as stat2 } from "fs/promises";
-import path54 from "path";
+import { readdir as readdir17, readFile as readFile30, stat as stat2 } from "fs/promises";
+import path56 from "path";
 
 // src/import/okf-limits.ts
 var DEFAULT_OKF_LIMITS = {
@@ -8591,22 +8724,22 @@ var DEFAULT_OKF_LIMITS = {
 // src/import/okf-read.ts
 var RESERVED = /* @__PURE__ */ new Set(["index.md", "log.md"]);
 async function listMarkdown(root, dir, limits, acc = [], visited = { n: 0 }) {
-  for (const entry of await readdir16(dir, { withFileTypes: true })) {
+  for (const entry of await readdir17(dir, { withFileTypes: true })) {
     if (++visited.n > limits.maxEntries) throw new Error(`OKF import: bundle exceeds max entry count (> ${limits.maxEntries})`);
-    const abs = path54.join(dir, entry.name);
+    const abs = path56.join(dir, entry.name);
     if (entry.isDirectory()) await listMarkdown(root, abs, limits, acc, visited);
     else if (entry.isFile() && entry.name.endsWith(".md")) {
-      acc.push(path54.relative(root, abs).split(path54.sep).join("/"));
+      acc.push(path56.relative(root, abs).split(path56.sep).join("/"));
       if (acc.length > limits.maxFiles) throw new Error(`OKF import: bundle exceeds max file count (> ${limits.maxFiles})`);
     }
   }
   return acc;
 }
 async function confinedInside(realRoot, rel) {
-  const real = await safeRealpath(path54.join(realRoot, rel));
+  const real = await safeRealpath(path56.join(realRoot, rel));
   return real && isInsideDir(real, realRoot) ? real : null;
 }
-async function readOkfBundle(bundleDir, overrides = {}) {
+async function readOkfBundle(bundleDir, overrides = {}, onWarn = (m) => status("!", warn(m))) {
   const limits = { ...DEFAULT_OKF_LIMITS, ...overrides };
   const realRoot = await safeRealpath(bundleDir);
   if (!realRoot) throw new Error(`OKF import: bundle not found: ${bundleDir}`);
@@ -8617,7 +8750,7 @@ async function readOkfBundle(bundleDir, overrides = {}) {
     if (RESERVED.has(rel)) continue;
     const real = await confinedInside(realRoot, rel);
     if (!real) {
-      status("!", warn(`OKF import: skipped path escaping bundle: ${rel}`));
+      onWarn(`OKF import: skipped path escaping bundle: ${rel}`);
       continue;
     }
     const size = (await stat2(real)).size;
@@ -8626,7 +8759,7 @@ async function readOkfBundle(bundleDir, overrides = {}) {
     const parsed = parseFrontmatterStatus(await readFile30(real, "utf-8"));
     const type = parsed.meta.type;
     if (parsed.malformedFrontmatter || typeof type !== "string" || type.trim() === "") {
-      status("!", warn(`OKF import: skipped doc without a valid type: ${rel}`));
+      onWarn(`OKF import: skipped doc without a valid type: ${rel}`);
       continue;
     }
     docs.push({ relPath: rel, meta: parsed.meta, body: parsed.body });
@@ -8696,7 +8829,12 @@ function okfDocToPage(doc, ctx) {
   const slug = slugFromRelPath(doc.relPath);
   const fields = buildPageFields(doc, ctx, slug);
   const isNative = doc.meta["x-llmwiki"] !== void 0;
-  const body = isNative ? okfLinksToWikilinks(canonicalBody(doc.body), ctx.titleOf) : doc.body;
+  const resolveLink = (linkPath) => {
+    const linkSlug = slugFromRelPath(linkPath);
+    const title = ctx.titleOf(linkSlug);
+    return title !== null ? { slug: linkSlug, title } : null;
+  };
+  const body = isNative ? okfLinksToWikilinks(canonicalBody(doc.body), resolveLink) : doc.body;
   const pageBody = `${buildFrontmatter(fields)}
 ${body}`;
   return {
@@ -8712,7 +8850,7 @@ ${body}`;
 
 // src/import/okf-collision.ts
 import { access } from "fs/promises";
-import path55 from "path";
+import path57 from "path";
 async function fileExists(p) {
   try {
     await access(p);
@@ -8730,9 +8868,8 @@ async function filterCollisions(root, pages) {
     let reason = null;
     if (claimed.has(page.slug)) reason = "duplicate-in-bundle";
     else if (pendingSlugs.has(page.slug)) reason = "pending-candidate";
-    else if (await fileExists(path55.join(root, CONCEPTS_DIR, `${page.slug}.md`)) || await fileExists(path55.join(root, QUERIES_DIR, `${page.slug}.md`))) reason = "live-page";
+    else if (await fileExists(path57.join(root, CONCEPTS_DIR, `${page.slug}.md`)) || await fileExists(path57.join(root, QUERIES_DIR, `${page.slug}.md`))) reason = "live-page";
     if (reason) {
-      status("!", warn(`OKF import: skipped ${page.okfPath} (slug "${page.slug}" collides: ${reason})`));
       skipped.push({ slug: page.slug, okfPath: page.okfPath, reason });
     } else {
       claimed.add(page.slug);
@@ -8744,7 +8881,7 @@ async function filterCollisions(root, pages) {
 
 // src/import/okf-import.ts
 function bundleIdFor(bundleDir) {
-  return slugify(path56.basename(path56.resolve(bundleDir))) || "bundle";
+  return slugify(path58.basename(path58.resolve(bundleDir))) || "bundle";
 }
 function titleResolver(docs) {
   const map = /* @__PURE__ */ new Map();
@@ -8754,14 +8891,19 @@ function titleResolver(docs) {
   }
   return (slug) => map.get(slug) ?? null;
 }
-async function importOkfBundle(bundleDir, root, overrides = {}) {
-  const docs = await readOkfBundle(bundleDir, overrides);
+async function importOkfBundle(bundleDir, root, overrides = {}, onWarn) {
+  const docs = await readOkfBundle(bundleDir, overrides, onWarn);
   const ctx = { bundleId: bundleIdFor(bundleDir), titleOf: titleResolver(docs) };
   const mapped = docs.map((d) => okfDocToPage(d, ctx));
   const { kept, skipped } = await filterCollisions(root, mapped);
   return { pages: kept, skipped };
 }
 
+// src/commands/import-core.ts
+function isWritable(page) {
+  return page.slug.length > 0 && validateWikiPage(page.body);
+}
+
 // src/import/okf-refresh.ts
 async function safelyUpdateEmbeddings2(root, slugs) {
   try {
@@ -8777,88 +8919,115 @@ async function refreshAfterImport(root, slugs) {
   await safelyUpdateEmbeddings2(root, slugs);
 }
 
-// src/commands/import.ts
-async function stageCandidate(root, page) {
-  await writeCandidate(root, {
-    title: page.title,
-    slug: page.slug,
-    summary: page.summary,
-    sources: page.sources,
-    body: page.body,
-    reviewMode: "imported",
-    heldReasons: [{ code: "imported-okf" }],
-    targetDirectory: page.targetDirectory,
-    okfPath: page.okfPath
-  });
-}
-function isWritable(page) {
-  return page.slug.length > 0 && validateWikiPage(page.body);
-}
-function validForWrite(page) {
-  if (isWritable(page)) return true;
-  status("!", warn(`OKF import: ${page.okfPath} (slug "${page.slug}") failed validation; skipped.`));
-  return false;
+// src/import/run-errors.ts
+var LockUnavailableError = class extends Error {
+  constructor(message = "Could not acquire lock. Try again later.") {
+    super(message);
+    this.name = "LockUnavailableError";
+  }
+};
+var QueueFullError = class extends Error {
+  constructor(message = "Review queue would exceed the cap; approve/reject pending candidates first.") {
+    super(message);
+    this.name = "QueueFullError";
+  }
+};
+
+// src/import/run.ts
+var toImported = (p) => ({ slug: p.slug, okfPath: p.okfPath, targetDirectory: p.targetDirectory });
+function partition(pages, collisionSkips) {
+  const valid = [];
+  const invalid = [];
+  for (const p of pages) {
+    if (isWritable(p)) valid.push(p);
+    else invalid.push({ slug: p.slug, okfPath: p.okfPath, reason: "invalid-page" });
+  }
+  return { valid, skipped: [...collisionSkips, ...invalid] };
+}
+async function stageAll(root, valid) {
+  for (const page of valid) {
+    await writeCandidate(root, {
+      title: page.title,
+      slug: page.slug,
+      summary: page.summary,
+      sources: page.sources,
+      body: page.body,
+      reviewMode: "imported",
+      heldReasons: [{ code: "imported-okf" }],
+      targetDirectory: page.targetDirectory,
+      okfPath: page.okfPath
+    });
+  }
 }
-async function writeTrusted(root, pages) {
+async function writeAll(root, valid) {
   const written = [];
   try {
-    for (const page of pages) {
+    for (const page of valid) {
       const dir = page.targetDirectory === "queries" ? QUERIES_DIR : CONCEPTS_DIR;
-      await atomicWrite(path57.join(root, dir, `${page.slug}.md`), page.body);
+      await atomicWrite(path59.join(root, dir, `${page.slug}.md`), page.body);
       written.push(page.slug);
     }
   } finally {
     if (written.length) await refreshAfterImport(root, written);
   }
 }
-function reportPreview(pages, skipped) {
-  for (const p of pages) {
-    if (isWritable(p)) {
-      status("+", `${p.slug} (${p.targetDirectory}) \u2190 ${p.okfPath}`);
-    } else {
-      status("!", warn(`invalid (empty slug/title/body): ${p.okfPath}`));
-    }
+async function runOkfImport(root, dir, opts = {}) {
+  const warnings = [];
+  if (opts.dryRun) {
+    const { pages, skipped } = await importOkfBundle(dir, root, {}, (m) => warnings.push(m));
+    const { valid, skipped: allSkipped } = partition(pages, skipped);
+    return { mode: "dry-run", pages: valid.map(toImported), skipped: allSkipped, warnings, nextAction: "Re-run without dryRun to apply." };
+  }
+  const locked = await withQuiet(() => acquireLock(root));
+  if (!locked) throw new LockUnavailableError();
+  try {
+    const { pages, skipped } = await importOkfBundle(dir, root, {}, (m) => warnings.push(m));
+    const { valid, skipped: allSkipped } = partition(pages, skipped);
+    if (opts.maxNewCandidates !== void 0 && !opts.trusted) {
+      const pending = (await listCandidates(root)).length;
+      if (pending + valid.length > opts.maxNewCandidates) throw new QueueFullError();
+    }
+    if (opts.trusted) await writeAll(root, valid);
+    else await stageAll(root, valid);
+    return {
+      mode: opts.trusted ? "written" : "staged",
+      pages: valid.map(toImported),
+      skipped: allSkipped,
+      warnings,
+      nextAction: opts.trusted ? `${valid.length} page(s) written live.` : "Review and approve before it goes live: llmwiki review list."
+    };
+  } finally {
+    await releaseLock(root);
   }
-  for (const s of skipped) status("!", warn(`skip ${s.okfPath} \u2014 ${s.reason}`));
 }
-async function previewImport(root, okf) {
-  const { pages, skipped } = await importOkfBundle(okf, root);
-  const writable = pages.filter(isWritable).length;
-  const dropped = skipped.length + (pages.length - writable);
-  status("i", dim(`Dry run \u2014 would import ${writable} page(s); skip ${dropped}.`));
-  reportPreview(pages, skipped);
+
+// src/commands/import.ts
+function printReport(report) {
+  for (const w of report.warnings) status("!", warn(w));
+  for (const p of report.pages) status("+", `${p.slug} (${p.targetDirectory}) \u2190 ${p.okfPath}`);
+  for (const s of report.skipped) status("!", warn(`skip ${s.okfPath} \u2014 ${s.reason}`));
+  const verb = report.mode === "written" ? "wrote" : report.mode === "dry-run" ? "would import" : "staged";
+  status("+", success(`OKF import: ${verb} ${report.pages.length} page(s); skipped ${report.skipped.length}.`));
 }
 async function importCommand(root, options) {
   if (!options.okf) throw new Error("import: --okf <dir> is required");
-  if (options.dryRun) {
-    await previewImport(root, options.okf);
-    return;
-  }
-  const locked = await acquireLock(root);
-  if (!locked) {
-    status("!", error("Could not acquire lock. Try again later."));
-    process.exitCode = 1;
-    return;
-  }
   try {
-    const { pages, skipped } = await importOkfBundle(options.okf, root);
-    const valid = pages.filter(validForWrite);
-    if (options.trusted) await writeTrusted(root, valid);
-    else {
-      for (const p of valid) await stageCandidate(root, p);
-    }
-    const verb = options.trusted ? "wrote" : "staged";
-    const dropped = skipped.length + (pages.length - valid.length);
-    status("+", success(`OKF import: ${verb} ${valid.length} page(s); skipped ${dropped}.`));
-  } finally {
-    await releaseLock(root);
+    const report = await runOkfImport(root, options.okf, { trusted: options.trusted, dryRun: options.dryRun });
+    printReport(report);
+  } catch (err) {
+    if (err instanceof LockUnavailableError) {
+      status("!", error(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    throw err;
   }
 }
 
 // src/commands/schema.ts
 import { existsSync as existsSync18 } from "fs";
 import { mkdir as mkdir10, writeFile as writeFile5 } from "fs/promises";
-import path58 from "path";
+import path60 from "path";
 async function schemaInitCommand() {
   const root = process.cwd();
   const defaults = buildDefaultSchema();
@@ -8867,7 +9036,7 @@ async function schemaInitCommand() {
     status("!", warn(`Schema file already exists at ${targetPath}`));
     return;
   }
-  await mkdir10(path58.dirname(targetPath), { recursive: true });
+  await mkdir10(path60.dirname(targetPath), { recursive: true });
   const serializable = {
     version: defaults.version,
     defaultKind: defaults.defaultKind,
@@ -8967,7 +9136,7 @@ async function reviewShowCommand(id) {
 }
 
 // src/commands/review-approve.ts
-import path59 from "path";
+import path61 from "path";
 
 // src/commands/review-helpers.ts
 async function runReviewUnderLock(id, underLock) {
@@ -9000,7 +9169,7 @@ async function approveUnderLock(root, id) {
     return;
   }
   const dir = candidate.targetDirectory === "queries" ? QUERIES_DIR : CONCEPTS_DIR;
-  const pagePath = path59.join(root, dir, `${candidate.slug}.md`);
+  const pagePath = path61.join(root, dir, `${candidate.slug}.md`);
   await atomicWrite(pagePath, candidate.body);
   status("+", success(`Approved \u2192 ${source(pagePath)}`));
   await persistCandidateSourceStates(root, candidate);
@@ -9057,21 +9226,21 @@ async function rejectUnderLock(root, id) {
 
 // src/commands/rules.ts
 import { existsSync as existsSync20 } from "fs";
-import path63 from "path";
+import path65 from "path";
 
 // src/compiler/rule-extractor.ts
 import { readFile as readFile32 } from "fs/promises";
-import path62 from "path";
+import path64 from "path";
 
 // src/compiler/rule-state.ts
 import { readFile as readFile31, writeFile as writeFile6, rename as rename4, mkdir as mkdir11 } from "fs/promises";
 import { existsSync as existsSync19 } from "fs";
-import path60 from "path";
+import path62 from "path";
 function emptyRuleState() {
   return { version: 1, indexHash: "", sources: {} };
 }
 async function readRuleState(root) {
-  const filePath = path60.join(root, RULE_STATE_FILE);
+  const filePath = path62.join(root, RULE_STATE_FILE);
   if (!existsSync19(filePath)) return emptyRuleState();
   try {
     return JSON.parse(await readFile31(filePath, "utf-8"));
@@ -9080,8 +9249,8 @@ async function readRuleState(root) {
   }
 }
 async function writeRuleState(root, state) {
-  await mkdir11(path60.join(root, LLMWIKI_DIR), { recursive: true });
-  const filePath = path60.join(root, RULE_STATE_FILE);
+  await mkdir11(path62.join(root, LLMWIKI_DIR), { recursive: true });
+  const filePath = path62.join(root, RULE_STATE_FILE);
   const tmpPath = `${filePath}.tmp`;
   await writeFile6(tmpPath, JSON.stringify(state, null, 2), "utf-8");
   await rename4(tmpPath, filePath);
@@ -9215,15 +9384,15 @@ function parseRules(toolOutput) {
 }
 
 // src/compiler/rule-candidates.ts
-import path61 from "path";
+import path63 from "path";
 import { createHash as createHash8 } from "crypto";
 var CONFIDENCE_VALUES = ["low", "medium", "high"];
 var STATUS_VALUES = ["proposed", "approved", "rejected"];
 function ruleCandidatePath(root, id) {
-  return path61.join(root, RULE_CANDIDATES_DIR, `${id}${CANDIDATE_JSON_EXT}`);
+  return path63.join(root, RULE_CANDIDATES_DIR, `${id}${CANDIDATE_JSON_EXT}`);
 }
 function ruleArchivePath(root, id) {
-  return path61.join(root, RULE_CANDIDATES_ARCHIVE_DIR, `${id}${CANDIDATE_JSON_EXT}`);
+  return path63.join(root, RULE_CANDIDATES_ARCHIVE_DIR, `${id}${CANDIDATE_JSON_EXT}`);
 }
 var CATEGORY_CAP = 64;
 var TITLE_CAP = 256;
@@ -9401,7 +9570,7 @@ async function readRuleCandidate(root, fileId) {
   }
 }
 async function listRuleCandidates(root) {
-  const dir = path61.join(root, RULE_CANDIDATES_DIR);
+  const dir = path63.join(root, RULE_CANDIDATES_DIR);
   const fileIds = await listCandidateFileIds(dir);
   const candidates = [];
   for (const fileId of fileIds) {
@@ -9488,7 +9657,7 @@ ${rule.description}`;
   );
 }
 async function extractForSource2(root, sourceFile, provenance, createdAt) {
-  const sourcePath = path62.join(root, SOURCES_DIR, sourceFile);
+  const sourcePath = path64.join(root, SOURCES_DIR, sourceFile);
   const raw = await readFile32(sourcePath, "utf-8");
   const hash = createHash9("sha256").update(raw).digest("hex");
   const { meta } = parseFrontmatter(raw);
@@ -9560,7 +9729,7 @@ function buildRuleCandidatesJson(candidates) {
 var RULE_EXPORT_PATH = "dist/exports/rule-candidates.json";
 async function rulesExtractCommand() {
   const root = process.cwd();
-  if (!existsSync20(path63.join(root, SOURCES_DIR))) {
+  if (!existsSync20(path65.join(root, SOURCES_DIR))) {
     status("!", warn("No sources found. Run `llmwiki ingest <url>` first."));
     return;
   }
@@ -9623,7 +9792,7 @@ async function rulesExportCommand(options = {}) {
   const root = process.cwd();
   const scope = resolveScope(options.scope);
   const candidates = await collectRuleCandidatesForExport(root, scope);
-  const outPath = path63.join(root, RULE_EXPORT_PATH);
+  const outPath = path65.join(root, RULE_EXPORT_PATH);
   await atomicWrite(outPath, buildRuleCandidatesJson(candidates));
   status(
     "+",
@@ -9708,8 +9877,8 @@ async function runRulesAction(work) {
 }
 
 // src/project/state.ts
-import { stat as stat3, readdir as readdir17, readFile as readFile33 } from "fs/promises";
-import path64 from "path";
+import { stat as stat3, readdir as readdir18, readFile as readFile33 } from "fs/promises";
+import path66 from "path";
 var MARKDOWN_EXT = ".md";
 async function collectProjectState(root) {
   const rootReadable = await isDirectory(root);
@@ -9745,31 +9914,31 @@ function brokenProjectState(root) {
 }
 async function collectDirPresence(root) {
   const [hasSourcesDir, hasWikiDir, hasInternalDir] = await Promise.all([
-    isDirectory(path64.join(root, SOURCES_DIR)),
-    isDirectory(path64.join(root, "wiki")),
-    isDirectory(path64.join(root, LLMWIKI_DIR))
+    isDirectory(path66.join(root, SOURCES_DIR)),
+    isDirectory(path66.join(root, "wiki")),
+    isDirectory(path66.join(root, LLMWIKI_DIR))
   ]);
   return { hasSourcesDir, hasWikiDir, hasInternalDir };
 }
 async function collectPageCounts(root, dirs) {
   const [sourceCount, conceptCount, queryCount, pendingCandidates, hasIndex] = await Promise.all([
-    dirs.hasSourcesDir ? countMarkdownFiles(path64.join(root, SOURCES_DIR)) : 0,
-    dirs.hasWikiDir ? countMarkdownFiles(path64.join(root, CONCEPTS_DIR)) : 0,
-    dirs.hasWikiDir ? countMarkdownFiles(path64.join(root, QUERIES_DIR)) : 0,
+    dirs.hasSourcesDir ? countMarkdownFiles(path66.join(root, SOURCES_DIR)) : 0,
+    dirs.hasWikiDir ? countMarkdownFiles(path66.join(root, CONCEPTS_DIR)) : 0,
+    dirs.hasWikiDir ? countMarkdownFiles(path66.join(root, QUERIES_DIR)) : 0,
     dirs.hasInternalDir ? safeCountCandidates(root) : 0,
-    dirs.hasWikiDir ? isFile(path64.join(root, INDEX_FILE)) : false
+    dirs.hasWikiDir ? isFile(path66.join(root, INDEX_FILE)) : false
   ]);
   return { sourceCount, conceptCount, queryCount, pendingCandidates, hasIndex };
 }
 async function collectMtimes(root, dirs) {
   const [latestWikiMtimeMs, latestSourceMtimeMs] = await Promise.all([
-    dirs.hasWikiDir ? safeMtime(path64.join(root, "wiki")) : Promise.resolve(null),
-    dirs.hasSourcesDir ? safeMtime(path64.join(root, SOURCES_DIR)) : Promise.resolve(null)
+    dirs.hasWikiDir ? safeMtime(path66.join(root, "wiki")) : Promise.resolve(null),
+    dirs.hasSourcesDir ? safeMtime(path66.join(root, SOURCES_DIR)) : Promise.resolve(null)
   ]);
   return { latestWikiMtimeMs, latestSourceMtimeMs };
 }
 async function collectLintCacheStatus(root) {
-  const cachePath = path64.join(root, LAST_LINT_FILE);
+  const cachePath = path66.join(root, LAST_LINT_FILE);
   const exists = await isFile(cachePath);
   if (!exists) return { present: false, entry: null };
   const entry = await readLintCacheEntry(cachePath);
@@ -9915,7 +10084,7 @@ async function safeMtime(target) {
 }
 async function countMarkdownFiles(dir) {
   try {
-    const entries = await readdir17(dir, { withFileTypes: true });
+    const entries = await readdir18(dir, { withFileTypes: true });
     let count = 0;
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(MARKDOWN_EXT)) count += 1;
@@ -10131,8 +10300,8 @@ function plural(count) {
 }
 
 // src/compiler/refresh-plan.ts
-import { readdir as readdir18 } from "fs/promises";
-import path65 from "path";
+import { readdir as readdir19 } from "fs/promises";
+import path67 from "path";
 function ownersOf2(slug, snapshot) {
   return Object.entries(snapshot.sources).filter(([, s]) => s.concepts.includes(slug)).map(([file, s]) => ({
     file,
@@ -10183,7 +10352,7 @@ async function resolveStaleRefresh(root) {
   }
   const snapshot = await buildFreshnessSnapshot(root, classified);
   const state = classified.state;
-  const pages = await scanWikiPages(path65.join(root, CONCEPTS_DIR));
+  const pages = await scanWikiPages(path67.join(root, CONCEPTS_DIR));
   const c = classifyPages(pages, snapshot);
   return {
     stateStatus: "ok",
@@ -10210,7 +10379,7 @@ function knownAffectedFor(state, changed, deleted) {
 async function listNewSkipped(root, state) {
   let files;
   try {
-    files = (await readdir18(path65.join(root, SOURCES_DIR))).filter((f) => f.endsWith(".md"));
+    files = (await readdir19(path67.join(root, SOURCES_DIR))).filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
@@ -10326,7 +10495,7 @@ function planDetailRows(plan) {
 }
 
 // src/commands/quickstart.ts
-import path66 from "path";
+import path68 from "path";
 var QUICKSTART_JSON_VERSION = 1;
 var VIEW_OPEN_ARGS_KEY = "view\0--open";
 var NOOP_RESTORE = () => {
@@ -10393,7 +10562,7 @@ async function runIngestStep(source2) {
   status("*", info(`Ingesting ${source2}`));
   try {
     const result = await ingestSource(process.cwd(), source2);
-    const relPath = path66.join(SOURCES_DIR, result.filename);
+    const relPath = path68.join(SOURCES_DIR, result.filename);
     status("+", success(`Ingested \u2192 ${relPath}`));
     return buildIngestSuccess(result, relPath);
   } catch (err) {
@@ -10642,7 +10811,7 @@ function appendNextLines(lines, next) {
 }
 
 // src/commands/context.ts
-import path67 from "path";
+import path69 from "path";
 
 // src/context/ranking.ts
 var WEIGHT_TITLE_MATCH = 0.5;
@@ -11466,7 +11635,7 @@ function appendPrimaryPages(lines, primary) {
   for (const page of primary) appendPrimaryPage(lines, page);
 }
 function appendPrimaryPage(lines, page) {
-  const pageFile = path67.join("wiki", page.pageDirectory, `${slugFromId(page.id)}.md`);
+  const pageFile = path69.join("wiki", page.pageDirectory, `${slugFromId(page.id)}.md`);
   lines.push(`### ${page.title} (\`${pageFile}\`)`);
   lines.push("");
   lines.push(`Why included: ${page.reasons.join(", ") || "(no signals)"}`);
@@ -11527,8 +11696,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z as z2 } from "zod";
 
 // src/status/collect.ts
-import path68 from "path";
-import { readdir as readdir19 } from "fs/promises";
+import path70 from "path";
+import { readdir as readdir20 } from "fs/promises";
 var MAX_STATUS_LIST = 100;
 function classifyConceptPages(scanned, snapshot) {
   const stalePages = [];
@@ -11549,7 +11718,7 @@ function lastCompileTime(sources) {
 }
 async function listSourceFilesOnDisk(root) {
   try {
-    const entries = await readdir19(path68.join(root, SOURCES_DIR));
+    const entries = await readdir20(path70.join(root, SOURCES_DIR));
     return entries.filter((f) => f.endsWith(".md"));
   } catch {
     return [];
@@ -11577,9 +11746,9 @@ async function collectStatus(root) {
   const classified = await readStateClassified(root);
   const snapshot = await buildFreshnessSnapshot(root, classified);
   const [conceptSummaries, queries, scannedConcepts, pendingCandidates, sourceFilesOnDisk] = await Promise.all([
-    collectPageSummaries(path68.join(root, CONCEPTS_DIR)),
-    collectPageSummaries(path68.join(root, QUERIES_DIR)),
-    scanWikiPages(path68.join(root, CONCEPTS_DIR)),
+    collectPageSummaries(path70.join(root, CONCEPTS_DIR)),
+    collectPageSummaries(path70.join(root, QUERIES_DIR)),
+    scanWikiPages(path70.join(root, CONCEPTS_DIR)),
     countCandidates(root),
     listSourceFilesOnDisk(root)
   ]);
@@ -11601,11 +11770,11 @@ async function collectStatus(root) {
 }
 
 // src/pages/read.ts
-import path69 from "path";
+import path71 from "path";
 var PAGE_DIRS2 = [CONCEPTS_DIR, QUERIES_DIR];
 async function readPageRecord2(root, slug) {
   for (const dir of PAGE_DIRS2) {
-    const content = await safeReadFile(path69.join(root, dir, `${slug}.md`));
+    const content = await safeReadFile(path71.join(root, dir, `${slug}.md`));
     if (!content) continue;
     const { meta, body } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -11620,7 +11789,7 @@ async function readPageRecord2(root, slug) {
 }
 
 // src/search/retrieval.ts
-import path70 from "path";
+import path72 from "path";
 function dedupePreservingOrder(slugs) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -11642,7 +11811,7 @@ async function pickSearchSlugs(root, question) {
     if (candidates.length > 0) return candidates.map((c) => c.slug);
   } catch {
   }
-  const indexContent = await safeReadFile(path70.join(root, INDEX_FILE));
+  const indexContent = await safeReadFile(path72.join(root, INDEX_FILE));
   const { pages } = await selectPages(question, indexContent);
   return pages;
 }
@@ -11655,13 +11824,21 @@ async function loadPageRecords(root, slugs) {
   return records;
 }
 
-// src/mcp/tools.ts
+// src/mcp/result.ts
 function jsonResult(payload) {
   return {
     content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
     structuredContent: { result: payload }
   };
 }
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+
+// src/mcp/tools.ts
 function registerWikiTools(server, root) {
   registerIngestTool(server, root);
   registerCompileTool(server, root);
@@ -11843,9 +12020,62 @@ function registerEvalTool(server, root) {
   );
 }
 
+// src/mcp/okf-tools.ts
+import { z as z3 } from "zod";
+var MAX_MCP_PENDING_CANDIDATES = 200;
+function registerOkfTools(server, root, maxPending = MAX_MCP_PENDING_CANDIDATES) {
+  server.registerTool(
+    "export_okf",
+    {
+      title: "Export OKF bundle",
+      description: "Export the wiki as an Open Knowledge Format (OKF) v0.1 bundle. `out` defaults to dist/exports/okf and must stay inside the project.",
+      inputSchema: { out: z3.string().optional().describe("Output dir for the bundle (must resolve inside the project root)") }
+    },
+    // withQuiet: the export core can print skipped-reference warnings via output.status;
+    // on the MCP stdio transport those would land on the JSON-RPC stream and corrupt it.
+    async ({ out }) => withQuiet(async () => {
+      try {
+        const dest = await confineUnderRoot(out ?? "dist/exports/okf", root, { mustExist: false });
+        const report = await runOkfExport(root, { out: dest });
+        return jsonResult({ outDir: report.outDir, fileCount: report.writtenPaths.length, files: report.writtenPaths.slice(0, 20), warnings: report.warnings });
+      } catch (err) {
+        return errorResult(err instanceof Error ? err.message : String(err));
+      }
+    })
+  );
+  server.registerTool(
+    "import_okf",
+    {
+      title: "Import OKF bundle (staged for review)",
+      description: "Import an OKF bundle from a path INSIDE the project as review candidates. Always staging-only \u2014 imported knowledge requires human review/approval before it enters the wiki. Use dryRun to preview.",
+      inputSchema: {
+        dir: z3.string().describe("Bundle directory (must resolve inside the project root)"),
+        dryRun: z3.boolean().optional().describe("Preview only \u2014 stage nothing")
+      }
+    },
+    // withQuiet: same stdio-stream guard as export_okf (the import core may emit warnings).
+    async ({ dir, dryRun }) => withQuiet(async () => {
+      try {
+        const bundle = await confineUnderRoot(dir, root, { mustExist: true });
+        const report = await runOkfImport(root, bundle, { trusted: false, dryRun, maxNewCandidates: maxPending });
+        return jsonResult({
+          mode: report.mode,
+          imported: report.pages.length,
+          pages: report.pages,
+          skipped: report.skipped,
+          warnings: report.warnings,
+          nextAction: report.mode === "dry-run" ? "Preview only \u2014 re-run without dryRun to stage these as review candidates." : "Imported docs are STAGED as review candidates \u2014 approve them via `llmwiki review` (human gate) before they enter the wiki."
+        });
+      } catch (err) {
+        return errorResult(err instanceof Error ? err.message : String(err));
+      }
+    })
+  );
+}
+
 // src/mcp/resources.ts
-import path71 from "path";
-import { readdir as readdir20 } from "fs/promises";
+import path73 from "path";
+import { readdir as readdir21 } from "fs/promises";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 function jsonContent(uri, payload) {
   return {
@@ -11880,7 +12110,7 @@ function registerIndexResource(server, root) {
       mimeType: "text/markdown"
     },
     async (uri) => {
-      const content = await safeReadFile(path71.join(root, INDEX_FILE));
+      const content = await safeReadFile(path73.join(root, INDEX_FILE));
       return { contents: [markdownContent(uri, content)] };
     }
   );
@@ -11947,23 +12177,23 @@ function registerQueryResource(server, root) {
   );
 }
 async function listSources(root) {
-  const sourcesPath = path71.join(root, SOURCES_DIR);
+  const sourcesPath = path73.join(root, SOURCES_DIR);
   let files;
   try {
-    files = await readdir20(sourcesPath);
+    files = await readdir21(sourcesPath);
   } catch {
     return [];
   }
   const records = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path71.join(sourcesPath, file));
+    const content = await safeReadFile(path73.join(sourcesPath, file));
     const { meta } = parseFrontmatter(content);
     records.push({ filename: file, ...meta });
   }
   return records;
 }
 async function loadPageWithMeta(root, dir, slug) {
-  const filePath = path71.join(root, dir, `${slug}.md`);
+  const filePath = path73.join(root, dir, `${slug}.md`);
   const content = await safeReadFile(filePath);
   if (!content) {
     throw new Error(`Page not found: ${dir}/${slug}.md`);
@@ -12002,10 +12232,10 @@ function registerEvalHistoryResource(server, root) {
   );
 }
 async function listPagesUnder(root, dir, scheme) {
-  const pagesPath = path71.join(root, dir);
+  const pagesPath = path73.join(root, dir);
   let files;
   try {
-    files = await readdir20(pagesPath);
+    files = await readdir21(pagesPath);
   } catch {
     return { resources: [] };
   }
@@ -12023,6 +12253,7 @@ async function startMCPServer(options) {
     instructions: "llmwiki is a knowledge compiler. Use ingest_source to add raw sources, compile_wiki to run the LLM pipeline, query_wiki for grounded answers, search_pages to retrieve relevant pages, and run_eval to score wiki quality. read_page, lint_wiki, wiki_status, and run_eval (fast suite, record: false) work without an API key and do not mutate state."
   });
   registerWikiTools(server, root);
+  registerOkfTools(server, root);
   registerWikiResources(server, root);
   const transport = new StdioServerTransport();
   await server.connect(transport);