llm-wiki-compiler 0.3.0 → 0.4.0

package/dist/cli.js

@@ -13,6 +13,8 @@ import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import { writeFile, rename, readFile, mkdir } from "fs/promises";
 import path from "path";
 import yaml from "js-yaml";
+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([
   "extracted",
   "merged",
@@ -49,6 +51,23 @@ async function atomicWrite(filePath, content) {
   await writeFile(tmpPath, content, "utf-8");
   await rename(tmpPath, filePath);
 }
+function isValidLineRange(start, end) {
+  return start >= MIN_LINE_NUMBER && end >= start;
+}
+function isMalformedCitationEntry(entry) {
+  const trimmed = entry.trim();
+  if (trimmed.length === 0) return true;
+  if (!trimmed.includes(":") && !trimmed.includes("#")) return false;
+  const match = SPAN_SUFFIX_PATTERN.exec(trimmed);
+  if (!match || !match.groups) return true;
+  const { colonStart, colonEnd, hashStart, hashEnd } = match.groups;
+  const start = colonStart ?? hashStart;
+  const end = colonEnd ?? hashEnd;
+  if (start === void 0) return false;
+  const startLine = Number(start);
+  const endLine = end === void 0 ? startLine : Number(end);
+  return !isValidLineRange(startLine, endLine);
+}
 async function safeReadFile(filePath) {
   try {
     return await readFile(filePath, "utf-8");
@@ -120,6 +139,8 @@ var PROVIDER_MODELS = {
   minimax: "MiniMax-M2.7"
 };
 var OLLAMA_DEFAULT_HOST = "http://localhost:11434/v1";
+var OPENAI_DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var OLLAMA_DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
 var SOURCES_DIR = "sources";
 var CONCEPTS_DIR = "wiki/concepts";
 var QUERIES_DIR = "wiki/queries";
@@ -324,11 +345,11 @@ async function ingest(source2) {
 }
 
 // src/commands/compile.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 
 // src/compiler/index.ts
-import { readFile as readFile8 } from "fs/promises";
-import path16 from "path";
+import { readFile as readFile10 } from "fs/promises";
+import path18 from "path";
 
 // src/utils/state.ts
 import { readFile as readFile3, writeFile as writeFile3, rename as rename2, mkdir as mkdir3, copyFile } from "fs/promises";
@@ -556,6 +577,15 @@ var AnthropicProvider = class {
 
 // src/providers/openai.ts
 import OpenAI from "openai";
+function readTimeoutEnv(name) {
+  const raw = process.env[name]?.trim();
+  if (!raw) return void 0;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function resolveOpenAITimeoutMs() {
+  return readTimeoutEnv("LLMWIKI_REQUEST_TIMEOUT_MS");
+}
 function translateToolToOpenAI(tool) {
   return {
     type: "function",
@@ -575,11 +605,13 @@ var OpenAIProvider = class {
     this.model = model;
     this.configuredEmbeddingModel = options.embeddingModel;
     const resolvedKey = options.apiKey ?? process.env.OPENAI_API_KEY ?? "";
+    const timeout = options.timeoutMs ?? resolveOpenAITimeoutMs() ?? OPENAI_DEFAULT_TIMEOUT_MS;
     this.client = new OpenAI({
       apiKey: resolvedKey,
-      baseURL: options.baseURL ?? null
+      baseURL: options.baseURL ?? null,
+      timeout
     });
-    this.embeddingsClient = options.embeddingsBaseURL ? new OpenAI({ apiKey: resolvedKey, baseURL: options.embeddingsBaseURL }) : this.client;
+    this.embeddingsClient = options.embeddingsBaseURL ? new OpenAI({ apiKey: resolvedKey, baseURL: options.embeddingsBaseURL, timeout }) : this.client;
   }
   /** Send a single non-streaming completion request. */
   async complete(system, messages, maxTokens) {
@@ -645,13 +677,17 @@ var OpenAIProvider = class {
 };
 
 // src/providers/ollama.ts
+function resolveOllamaTimeoutMs(explicit) {
+  return explicit ?? readTimeoutEnv("OLLAMA_TIMEOUT_MS") ?? readTimeoutEnv("LLMWIKI_REQUEST_TIMEOUT_MS") ?? OLLAMA_DEFAULT_TIMEOUT_MS;
+}
 var OllamaProvider = class extends OpenAIProvider {
   constructor(model, options) {
     super(model, {
       baseURL: options.baseURL,
       apiKey: "ollama",
       embeddingsBaseURL: options.embeddingsBaseURL,
-      embeddingModel: options.embeddingModel
+      embeddingModel: options.embeddingModel,
+      timeoutMs: resolveOllamaTimeoutMs(options.timeoutMs)
     });
   }
   /** Ollama ships a dedicated embedding model (nomic-embed-text). */
@@ -1065,7 +1101,14 @@ ${relatedPages}` : "";
     "Source attribution: at the end of each prose paragraph, append a citation",
     "marker showing which source file(s) the paragraph drew from.",
     "Format: ^[filename.md] for single-source, ^[source-a.md, source-b.md] for multi-source.",
-    "Place citations only at the end of prose paragraphs \u2014 not on headings, list items, or code blocks.",
+    "When a single sentence makes a specific factual claim and you can identify the",
+    "exact line range it came from, you may use the claim-level form",
+    "^[filename.md:START-END] (or ^[filename.md#LSTART-LEND]) at the end of that",
+    "sentence \u2014 START and END are 1-indexed line numbers in the source file.",
+    "Paragraph-level citations remain the default; only switch to claim-level form",
+    "when it materially improves verifiability and the line range is unambiguous.",
+    "Place citations only at the end of prose paragraphs or sentences \u2014 not on",
+    "headings, list items, or code blocks.",
     "Source filenames are visible as `--- SOURCE: filename.md ---` headers in the content below.",
     "",
     "If a paragraph is your inference rather than a direct extraction, leave it",
@@ -1106,6 +1149,20 @@ function mapRawConcept(c) {
     inferredParagraphs: typeof c.inferred_paragraphs === "number" && Number.isInteger(c.inferred_paragraphs) && c.inferred_paragraphs >= 0 ? c.inferred_paragraphs : void 0
   };
 }
+function buildSeedPagePrompt(seed, rule, relatedPagesContent) {
+  const minLinks = rule.minWikilinks;
+  const linkExpectation = minLinks > 0 ? `Include at least ${minLinks} [[wikilinks]] to related pages.` : "Use [[wikilinks]] when referencing other pages.";
+  return [
+    `You are a wiki author. Write a ${seed.kind} page titled "${seed.title}".`,
+    `Page-kind guidance: ${rule.description}`,
+    `Summary line for context: ${seed.summary}`,
+    "Draw facts only from the related wiki pages provided below.",
+    linkExpectation,
+    "Write in a neutral, informative tone. Be concise but thorough.",
+    "\n\n--- RELATED PAGES ---\n\n",
+    relatedPagesContent
+  ].join("\n");
+}
 function parseConcepts(toolOutput) {
   try {
     const parsed = JSON.parse(toolOutput);
@@ -1116,6 +1173,149 @@ function parseConcepts(toolOutput) {
   }
 }
 
+// src/schema/types.ts
+var PAGE_KINDS = [
+  "concept",
+  "entity",
+  "comparison",
+  "overview"
+];
+
+// src/schema/defaults.ts
+var DEFAULT_MIN_LINKS = {
+  concept: 0,
+  entity: 1,
+  comparison: 2,
+  overview: 3
+};
+var DEFAULT_DESCRIPTIONS = {
+  concept: "A standalone idea, technique, or pattern worth documenting.",
+  entity: "A specific thing \u2014 a person, product, organization, or named artifact.",
+  comparison: "A side-by-side analysis weighing two or more concepts or entities.",
+  overview: "A top-down map page that situates several concepts within a domain."
+};
+function buildDefaultKindRules() {
+  return {
+    concept: { minWikilinks: DEFAULT_MIN_LINKS.concept, description: DEFAULT_DESCRIPTIONS.concept },
+    entity: { minWikilinks: DEFAULT_MIN_LINKS.entity, description: DEFAULT_DESCRIPTIONS.entity },
+    comparison: {
+      minWikilinks: DEFAULT_MIN_LINKS.comparison,
+      description: DEFAULT_DESCRIPTIONS.comparison
+    },
+    overview: {
+      minWikilinks: DEFAULT_MIN_LINKS.overview,
+      description: DEFAULT_DESCRIPTIONS.overview
+    }
+  };
+}
+function buildDefaultSchema() {
+  return {
+    version: 1,
+    defaultKind: "concept",
+    kinds: buildDefaultKindRules(),
+    seedPages: [],
+    loadedFrom: null
+  };
+}
+
+// src/schema/loader.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile6 } from "fs/promises";
+import path9 from "path";
+import yaml2 from "js-yaml";
+var SCHEMA_CANDIDATE_PATHS = [
+  ".llmwiki/schema.json",
+  ".llmwiki/schema.yaml",
+  ".llmwiki/schema.yml",
+  "wiki/.schema.yaml",
+  "wiki/.schema.yml"
+];
+function findSchemaPath(root) {
+  for (const candidate of SCHEMA_CANDIDATE_PATHS) {
+    const absolute = path9.join(root, candidate);
+    if (existsSync2(absolute)) return absolute;
+  }
+  return null;
+}
+function parseSchemaFile(filePath, content) {
+  const isJson = filePath.endsWith(".json");
+  const parsed = isJson ? JSON.parse(content) : yaml2.load(content);
+  if (parsed && typeof parsed === "object") return parsed;
+  return {};
+}
+function isPageKind(value) {
+  return typeof value === "string" && PAGE_KINDS.includes(value);
+}
+function mergeKindRule(defaults, override) {
+  if (!override) return defaults;
+  const minWikilinks = typeof override.minWikilinks === "number" ? override.minWikilinks : defaults.minWikilinks;
+  const description = typeof override.description === "string" ? override.description : defaults.description;
+  return { minWikilinks, description };
+}
+function mergeKinds(defaults, overrides) {
+  const merged = { ...defaults };
+  if (!overrides) return merged;
+  for (const kind of PAGE_KINDS) {
+    merged[kind] = mergeKindRule(defaults[kind], overrides[kind]);
+  }
+  return merged;
+}
+function normalizeSeedPage(entry) {
+  if (typeof entry.title !== "string" || entry.title.trim() === "") return null;
+  if (!isPageKind(entry.kind)) return null;
+  const summary = typeof entry.summary === "string" ? entry.summary : "";
+  const relatedSlugs = Array.isArray(entry.relatedSlugs) ? entry.relatedSlugs.filter((slug) => typeof slug === "string") : void 0;
+  return { title: entry.title, kind: entry.kind, summary, relatedSlugs };
+}
+function normalizeSeedPages(entries) {
+  if (!Array.isArray(entries)) return [];
+  return entries.map(normalizeSeedPage).filter((entry) => entry !== null);
+}
+function applyOverrides(defaults, overrides, loadedFrom) {
+  const defaultKind = isPageKind(overrides.defaultKind) ? overrides.defaultKind : defaults.defaultKind;
+  return {
+    version: 1,
+    defaultKind,
+    kinds: mergeKinds(defaults.kinds, overrides.kinds),
+    seedPages: normalizeSeedPages(overrides.seedPages),
+    loadedFrom
+  };
+}
+async function loadSchema(root) {
+  const defaults = buildDefaultSchema();
+  const schemaPath = findSchemaPath(root);
+  if (!schemaPath) return defaults;
+  const raw = await readFile6(schemaPath, "utf-8");
+  const parsed = parseSchemaFile(schemaPath, raw);
+  return applyOverrides(defaults, parsed, schemaPath);
+}
+function defaultSchemaInitPath(root) {
+  return path9.join(root, SCHEMA_CANDIDATE_PATHS[0]);
+}
+
+// src/schema/helpers.ts
+import yaml3 from "js-yaml";
+var WIKILINK_PATTERN = /\[\[([^\]]+)\]\]/g;
+function resolvePageKind(rawKind, schema) {
+  if (typeof rawKind === "string" && PAGE_KINDS.includes(rawKind)) {
+    return rawKind;
+  }
+  return schema.defaultKind;
+}
+function countWikilinks(body) {
+  const matches = body.match(WIKILINK_PATTERN);
+  return matches ? matches.length : 0;
+}
+function serializeSchemaToYaml(schema) {
+  const serializable = {
+    version: schema.version,
+    defaultKind: schema.defaultKind,
+    kinds: schema.kinds,
+    seedPages: schema.seedPages
+  };
+  return yaml3.dump(serializable, { lineWidth: -1, quotingType: '"' });
+}
+
 // src/compiler/deps.ts
 function buildConceptToSourcesMap(sources) {
   const conceptMap = /* @__PURE__ */ new Map();
@@ -1262,7 +1462,7 @@ async function freezeFailedExtractions(root, results, frozenSlugs) {
 }
 
 // src/compiler/orphan.ts
-import path9 from "path";
+import path10 from "path";
 async function markOrphaned(root, sourceFile, state) {
   const sourceEntry = state.sources[sourceFile];
   if (!sourceEntry) return;
@@ -1288,7 +1488,7 @@ async function orphanUnownedFrozenPages(root, frozenSlugs) {
   }
 }
 async function orphanPage(root, slug, reason) {
-  const pagePath = path9.join(root, CONCEPTS_DIR, `${slug}.md`);
+  const pagePath = path10.join(root, CONCEPTS_DIR, `${slug}.md`);
   const content = await safeReadFile(pagePath);
   if (!content) return;
   const { meta } = parseFrontmatter(content);
@@ -1299,18 +1499,18 @@ async function orphanPage(root, slug, reason) {
 }
 
 // src/compiler/resolver.ts
-import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
-import path10 from "path";
-import { existsSync as existsSync2 } from "fs";
+import { readdir as readdir2, readFile as readFile7 } from "fs/promises";
+import path11 from "path";
+import { existsSync as existsSync3 } from "fs";
 async function buildTitleIndex(root) {
-  const conceptsDir = path10.join(root, CONCEPTS_DIR);
-  if (!existsSync2(conceptsDir)) return [];
+  const conceptsDir = path11.join(root, CONCEPTS_DIR);
+  if (!existsSync3(conceptsDir)) return [];
   const files = await readdir2(conceptsDir);
   const pages = [];
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = path10.join(conceptsDir, file);
-    const content = await readFile6(filePath, "utf-8");
+    const filePath = path11.join(conceptsDir, file);
+    const content = await readFile7(filePath, "utf-8");
     const { meta } = parseFrontmatter(content);
     if (meta.title && typeof meta.title === "string" && !meta.orphaned) {
       pages.push({
@@ -1364,7 +1564,7 @@ function addWikilinks(body, titles, selfTitle) {
     const matches = findTitleMatches(result, page.title);
     for (const m of matches.reverse()) {
       if (!isLinkablePosition(result, m.start, m.end)) continue;
-      result = result.slice(0, m.start) + `[[${page.title}]]` + result.slice(m.end);
+      result = result.slice(0, m.start) + `[[${page.slug}|${page.title}]]` + result.slice(m.end);
     }
   }
   return result;
@@ -1396,7 +1596,7 @@ async function resolveInboundLinks(titleIndex, newSlugs) {
   let count = 0;
   for (const page of titleIndex) {
     if (newSlugs.includes(page.slug)) continue;
-    const content = await readFile6(page.filePath, "utf-8");
+    const content = await readFile7(page.filePath, "utf-8");
     const { body } = parseFrontmatter(content);
     const linked = addWikilinks(body, newTitles, page.title);
     if (linked !== body) {
@@ -1408,7 +1608,7 @@ async function resolveInboundLinks(titleIndex, newSlugs) {
   return count;
 }
 async function linkPage(page, titleIndex) {
-  const content = await readFile6(page.filePath, "utf-8");
+  const content = await readFile7(page.filePath, "utf-8");
   const { body } = parseFrontmatter(content);
   const linked = addWikilinks(body, titleIndex, page.title);
   if (linked === body) return false;
@@ -1419,17 +1619,17 @@ async function linkPage(page, titleIndex) {
 
 // src/compiler/indexgen.ts
 import { readdir as readdir3 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 async function generateIndex(root) {
   status("*", info("Generating index..."));
-  const conceptsPath = path11.join(root, CONCEPTS_DIR);
-  const queriesPath = path11.join(root, QUERIES_DIR);
+  const conceptsPath = path12.join(root, CONCEPTS_DIR);
+  const queriesPath = path12.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 = path11.join(root, INDEX_FILE);
+  const indexPath = path12.join(root, INDEX_FILE);
   await atomicWrite(indexPath, indexContent);
   const total = concepts.length + queries.length;
   status("+", success(`Index updated with ${total} pages.`));
@@ -1443,7 +1643,7 @@ async function scanWikiPages(dirPath) {
   }
   const scanned = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path11.join(dirPath, file));
+    const content = await safeReadFile(path12.join(dirPath, file));
     const { meta } = parseFrontmatter(content);
     scanned.push({ slug: file.replace(/\.md$/, ""), meta });
   }
@@ -1463,12 +1663,12 @@ function stripWikilinks(text) {
 function buildIndexContent(concepts, queries) {
   const lines = ["# Knowledge Wiki", "", "## Concepts", ""];
   for (const page of concepts) {
-    lines.push(`- **[[${page.title}]]** \u2014 ${stripWikilinks(page.summary)}`);
+    lines.push(`- **[[${page.slug}|${page.title}]]** \u2014 ${stripWikilinks(page.summary)}`);
   }
   if (queries.length > 0) {
     lines.push("", "## Saved Queries", "");
     for (const page of queries) {
-      lines.push(`- **[[${page.title}]]** \u2014 ${stripWikilinks(page.summary)}`);
+      lines.push(`- **[[${page.slug}|${page.title}]]** \u2014 ${stripWikilinks(page.summary)}`);
     }
   }
   const total = concepts.length + queries.length;
@@ -1480,7 +1680,7 @@ function buildIndexContent(concepts, queries) {
 
 // src/compiler/obsidian.ts
 import { readdir as readdir4 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 var ABBREVIATION_MIN_WORDS = 3;
 var SWAP_CONJUNCTIONS = [" and ", " or "];
 function addObsidianMeta(frontmatter, conceptTitle, tags) {
@@ -1522,11 +1722,11 @@ function generateAbbreviation(title) {
   return abbreviation;
 }
 async function generateMOC(root) {
-  const conceptsPath = path12.join(root, CONCEPTS_DIR);
+  const conceptsPath = path13.join(root, CONCEPTS_DIR);
   const pages = await loadConceptPages(conceptsPath);
   const tagGroups = groupPagesByTag(pages);
   const content = buildMOCContent(tagGroups);
-  await atomicWrite(path12.join(root, MOC_FILE), content);
+  await atomicWrite(path13.join(root, MOC_FILE), content);
 }
 async function loadConceptPages(conceptsPath) {
   let files;
@@ -1538,13 +1738,14 @@ async function loadConceptPages(conceptsPath) {
   const pages = [];
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const content = await safeReadFile(path12.join(conceptsPath, file));
+    const content = await safeReadFile(path13.join(conceptsPath, file));
     if (!content) continue;
     const { meta } = parseFrontmatter(content);
     if (meta.orphaned) continue;
-    const title = typeof meta.title === "string" ? meta.title : file.replace(/\.md$/, "");
+    const slug = file.replace(/\.md$/, "");
+    const title = typeof meta.title === "string" ? meta.title : slug;
     const tags = Array.isArray(meta.tags) ? meta.tags : [];
-    pages.push({ title, tags });
+    pages.push({ slug, title, tags });
   }
   return pages;
 }
@@ -1552,21 +1753,21 @@ function groupPagesByTag(pages) {
   const groups = /* @__PURE__ */ new Map();
   for (const page of pages) {
     if (page.tags.length === 0) {
-      appendToGroup(groups, "Uncategorized", page.title);
+      appendToGroup(groups, "Uncategorized", page);
       continue;
     }
     for (const tag of page.tags) {
-      appendToGroup(groups, tag, page.title);
+      appendToGroup(groups, tag, page);
     }
   }
   return groups;
 }
-function appendToGroup(groups, key, title) {
+function appendToGroup(groups, key, page) {
   const existing = groups.get(key);
   if (existing) {
-    existing.push(title);
+    existing.push(page);
   } else {
-    groups.set(key, [title]);
+    groups.set(key, [page]);
   }
 }
 function buildMOCContent(tagGroups) {
@@ -1577,10 +1778,10 @@ function buildMOCContent(tagGroups) {
     return a.localeCompare(b);
   });
   for (const tag of sortedTags) {
-    const titles = tagGroups.get(tag) ?? [];
+    const pages = tagGroups.get(tag) ?? [];
     lines.push(`## ${tag}`, "");
-    for (const title of titles.sort()) {
-      lines.push(`- [[${title}]]`);
+    for (const page of pages.sort((a, b) => a.title.localeCompare(b.title))) {
+      lines.push(`- [[${page.slug}|${page.title}]]`);
     }
     lines.push("");
   }
@@ -1588,9 +1789,9 @@ function buildMOCContent(tagGroups) {
 }
 
 // src/utils/embeddings.ts
-import { readFile as readFile7, readdir as readdir5 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import path13 from "path";
+import { readFile as readFile8, readdir as readdir5 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import path14 from "path";
 function cosineSimilarity(a, b) {
   if (a.length !== b.length || a.length === 0) return 0;
   let dot = 0;
@@ -1613,13 +1814,13 @@ function findTopK(queryVec, store, k) {
   return scored.slice(0, k).map((item) => item.entry);
 }
 async function readEmbeddingStore(root) {
-  const filePath = path13.join(root, EMBEDDINGS_FILE);
-  if (!existsSync3(filePath)) return null;
-  const raw = await readFile7(filePath, "utf-8");
+  const filePath = path14.join(root, EMBEDDINGS_FILE);
+  if (!existsSync4(filePath)) return null;
+  const raw = await readFile8(filePath, "utf-8");
   return JSON.parse(raw);
 }
 async function writeEmbeddingStore(root, store) {
-  const filePath = path13.join(root, EMBEDDINGS_FILE);
+  const filePath = path14.join(root, EMBEDDINGS_FILE);
   await atomicWrite(filePath, JSON.stringify(store, null, 2));
 }
 async function findRelevantPages(root, question) {
@@ -1640,7 +1841,7 @@ async function findRelevantPages(root, question) {
 async function collectPageRecords(root) {
   const records = [];
   for (const dir of [CONCEPTS_DIR, QUERIES_DIR]) {
-    const absDir = path13.join(root, dir);
+    const absDir = path14.join(root, dir);
     let files;
     try {
       files = await readdir5(absDir);
@@ -1648,7 +1849,7 @@ async function collectPageRecords(root) {
       continue;
     }
     for (const file of files.filter((f) => f.endsWith(".md"))) {
-      const content = await safeReadFile(path13.join(absDir, file));
+      const content = await safeReadFile(path14.join(absDir, file));
       const { meta } = parseFrontmatter(content);
       if (meta.orphaned || typeof meta.title !== "string") continue;
       records.push({
@@ -1741,8 +1942,8 @@ async function updateEmbeddings(root, changedSlugs) {
 
 // src/compiler/candidates.ts
 import { readdir as readdir6, rename as rename3, unlink as unlink2, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import path14 from "path";
+import { existsSync as existsSync5 } from "fs";
+import path15 from "path";
 import { randomBytes } from "crypto";
 var ID_SUFFIX_BYTES = 4;
 var CANDIDATE_EXT = ".json";
@@ -1751,10 +1952,10 @@ function buildCandidateId(slug) {
   return `${slug}-${suffix}`;
 }
 function candidatePath(root, id) {
-  return path14.join(root, CANDIDATES_DIR, `${id}${CANDIDATE_EXT}`);
+  return path15.join(root, CANDIDATES_DIR, `${id}${CANDIDATE_EXT}`);
 }
 function archivePath(root, id) {
-  return path14.join(root, CANDIDATES_ARCHIVE_DIR, `${id}${CANDIDATE_EXT}`);
+  return path15.join(root, CANDIDATES_ARCHIVE_DIR, `${id}${CANDIDATE_EXT}`);
 }
 async function writeCandidate(root, draft) {
   const candidate = {
@@ -1765,7 +1966,8 @@ async function writeCandidate(root, draft) {
     sources: draft.sources,
     body: draft.body,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...draft.sourceStates ? { sourceStates: draft.sourceStates } : {}
+    ...draft.sourceStates ? { sourceStates: draft.sourceStates } : {},
+    ...draft.schemaViolations ? { schemaViolations: draft.schemaViolations } : {}
   };
   await atomicWrite(candidatePath(root, candidate.id), JSON.stringify(candidate, null, 2));
   return candidate;
@@ -1804,8 +2006,8 @@ function isValidCandidate(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 = path14.join(root, CANDIDATES_DIR);
-  if (!existsSync4(dir)) return [];
+  const dir = path15.join(root, CANDIDATES_DIR);
+  if (!existsSync5(dir)) return [];
   const entries = await readdir6(dir, { withFileTypes: true });
   const candidates = [];
   for (const entry of entries) {
@@ -1823,15 +2025,15 @@ async function countCandidates(root) {
 }
 async function deleteCandidate(root, id) {
   const filePath = candidatePath(root, id);
-  if (!existsSync4(filePath)) return false;
+  if (!existsSync5(filePath)) return false;
   await unlink2(filePath);
   return true;
 }
 async function archiveCandidate(root, id) {
   const sourcePath = candidatePath(root, id);
-  if (!existsSync4(sourcePath)) return false;
+  if (!existsSync5(sourcePath)) return false;
   const target = archivePath(root, id);
-  await mkdir5(path14.dirname(target), { recursive: true });
+  await mkdir5(path15.dirname(target), { recursive: true });
   try {
     await rename3(sourcePath, target);
   } catch {
@@ -1842,151 +2044,493 @@ async function archiveCandidate(root, id) {
   return true;
 }
 
-// src/compiler/page-renderer.ts
-import { readdir as readdir7 } from "fs/promises";
-import path15 from "path";
-
-// src/compiler/provenance.ts
-function addProvenanceMeta(fields, concept) {
-  if (typeof concept.confidence === "number") {
-    fields.confidence = concept.confidence;
-  }
-  if (concept.provenanceState) {
-    fields.provenanceState = concept.provenanceState;
-  }
-  if (concept.contradictedBy && concept.contradictedBy.length > 0) {
-    fields.contradictedBy = concept.contradictedBy;
-  }
-  if (typeof concept.inferredParagraphs === "number") {
-    fields.inferredParagraphs = concept.inferredParagraphs;
+// src/linter/rules.ts
+import { readdir as readdir7, readFile as readFile9 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import path16 from "path";
+var MIN_BODY_LENGTH = 50;
+var WIKILINK_PATTERN2 = /\[\[([^\]]+)\]\]/g;
+var CITATION_PATTERN = /\^\[([^\]]+)\]/g;
+function findMatchesInContent(content, pattern) {
+  const results = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const matches = lines[i].matchAll(pattern);
+    for (const match of matches) {
+      results.push({ captured: match[1], line: i + 1 });
+    }
   }
+  return results;
 }
-function reportContradictionWarnings(conceptTitle, concept) {
-  const refs = concept.contradictedBy;
-  if (!refs || refs.length === 0) return;
-  const slugs = refs.map((r) => r.slug).join(", ");
-  status(
-    "!",
-    warn(`Contradiction reported on "${conceptTitle}" \u2014 conflicts with: ${slugs}`)
-  );
-}
-
-// src/compiler/page-renderer.ts
-var RELATED_PAGE_CONTEXT_LIMIT = 5;
-async function renderMergedPageContent(root, entry) {
-  const pagePath = path15.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
-  const existingPage = await safeReadFile(pagePath);
-  const relatedPages = await loadRelatedPages(root, entry.slug);
-  const system = buildPagePrompt(
-    entry.concept.concept,
-    entry.combinedContent,
-    existingPage,
-    relatedPages
+async function readMarkdownFiles(dirPath) {
+  if (!existsSync6(dirPath)) return [];
+  const entries = await readdir7(dirPath);
+  const mdFiles = entries.filter((f) => f.endsWith(".md"));
+  const results = await Promise.all(
+    mdFiles.map(async (fileName) => {
+      const filePath = path16.join(dirPath, fileName);
+      const content = await readFile9(filePath, "utf-8");
+      return { filePath, content };
+    })
   );
-  const pageBody = await callClaude({
-    system,
-    messages: [
-      { role: "user", content: `Write the wiki page for "${entry.concept.concept}".` }
-    ]
-  });
-  const frontmatter = buildMergedFrontmatter(entry, existingPage);
-  reportContradictionWarnings(entry.concept.concept, entry.concept);
-  return `${frontmatter}
-
-${pageBody}
-`;
+  return results;
 }
-function buildMergedFrontmatter(entry, existingPage) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = existingPage ? parseFrontmatter(existingPage) : null;
-  const createdAt = existing?.meta.createdAt && typeof existing.meta.createdAt === "string" ? existing.meta.createdAt : now;
-  const frontmatterFields = {
-    title: entry.concept.concept,
-    summary: entry.concept.summary,
-    sources: entry.sourceFiles,
-    createdAt,
-    updatedAt: now
-  };
-  addObsidianMeta(frontmatterFields, entry.concept.concept, entry.concept.tags ?? []);
-  addProvenanceMeta(frontmatterFields, entry.concept);
-  return buildFrontmatter(frontmatterFields);
+async function collectAllPages(root) {
+  const conceptPages = await readMarkdownFiles(path16.join(root, CONCEPTS_DIR));
+  const queryPages = await readMarkdownFiles(path16.join(root, QUERIES_DIR));
+  return [...conceptPages, ...queryPages];
 }
-async function loadRelatedPages(root, excludeSlug) {
-  const conceptsPath = path15.join(root, CONCEPTS_DIR);
-  let files;
-  try {
-    files = await readdir7(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(path15.join(conceptsPath, f));
-    if (!content) continue;
-    const { meta } = parseFrontmatter(content);
-    if (meta.orphaned) continue;
-    contents.push(content);
+function buildPageSlugSet(pages) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const page of pages) {
+    const baseName = path16.basename(page.filePath, ".md");
+    slugs.add(baseName.toLowerCase());
   }
-  return contents.join("\n\n---\n\n");
-}
-
-// src/compiler/index.ts
-import pLimit from "p-limit";
-function emptyCompileResult() {
-  return { compiled: 0, skipped: 0, deleted: 0, concepts: [], pages: [], errors: [] };
-}
-async function compile(root, options = {}) {
-  await compileAndReport(root, options);
+  return slugs;
 }
-async function compileAndReport(root, options = {}) {
-  header("llmwiki compile");
-  const locked = await acquireLock(root);
-  if (!locked) {
-    status("!", error("Could not acquire lock. Try again later."));
-    return {
-      ...emptyCompileResult(),
-      errors: ["Could not acquire .llmwiki/lock \u2014 another compile is in progress."]
-    };
-  }
-  try {
-    return await runCompilePipeline(root, options);
-  } finally {
-    await releaseLock(root);
+async function checkBrokenWikilinks(root) {
+  const pages = await collectAllPages(root);
+  const existingSlugs = buildPageSlugSet(pages);
+  const results = [];
+  for (const page of pages) {
+    for (const { captured, line } of findMatchesInContent(page.content, WIKILINK_PATTERN2)) {
+      const linkSlug = slugify(captured);
+      if (!existingSlugs.has(linkSlug)) {
+        results.push({
+          rule: "broken-wikilink",
+          severity: "error",
+          file: page.filePath,
+          message: `Broken wikilink [[${captured}]] \u2014 no matching page found`,
+          line
+        });
+      }
+    }
   }
+  return results;
 }
-function bucketChanges(changes) {
-  return {
-    toCompile: changes.filter((c) => c.status === "new" || c.status === "changed"),
-    deleted: changes.filter((c) => c.status === "deleted"),
-    unchanged: changes.filter((c) => c.status === "unchanged")
-  };
-}
-async function generatePagesPhase(root, extractions, frozenSlugs, options) {
-  const merged = mergeExtractions(extractions, frozenSlugs);
-  const sourceStates = options.review ? await buildExtractionSourceStates(root, extractions) : {};
-  const limit = pLimit(COMPILE_CONCURRENCY);
-  const errors = [];
-  const candidates = [];
-  const pages = await Promise.all(
-    merged.map((entry) => limit(async () => {
-      const result = await generateMergedPage(root, entry, options, sourceStates);
-      if (result.error) errors.push(result.error);
-      if (result.candidateId) candidates.push(result.candidateId);
-      return entry;
-    }))
-  );
-  return { pages, errors, candidates };
-}
-async function persistExtractionStates(root, extractions) {
-  for (const result of extractions) {
-    if (result.concepts.length === 0) continue;
-    await persistSourceState(root, result.sourcePath, result.sourceFile, result.concepts);
+async function checkOrphanedPages(root) {
+  const pages = await collectAllPages(root);
+  const results = [];
+  for (const page of pages) {
+    const { meta } = parseFrontmatter(page.content);
+    if (meta.orphaned === true) {
+      results.push({
+        rule: "orphaned-page",
+        severity: "warning",
+        file: page.filePath,
+        message: `Page is marked as orphaned`
+      });
+    }
   }
+  return results;
 }
-function summarizeCompile(buckets, generation, extractions, options) {
-  header("Compilation complete");
-  status("\u2713", success(
+async function checkMissingSummaries(root) {
+  const pages = await collectAllPages(root);
+  const results = [];
+  for (const page of pages) {
+    const { meta } = parseFrontmatter(page.content);
+    const summary = meta.summary;
+    const isMissing = !summary || typeof summary === "string" && summary.trim() === "";
+    if (isMissing) {
+      results.push({
+        rule: "missing-summary",
+        severity: "warning",
+        file: page.filePath,
+        message: `Page has no summary in frontmatter`
+      });
+    }
+  }
+  return results;
+}
+async function checkDuplicateConcepts(root) {
+  const pages = await collectAllPages(root);
+  const titleMap = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const { meta } = parseFrontmatter(page.content);
+    const title = typeof meta.title === "string" ? meta.title : "";
+    if (!title) continue;
+    const normalizedTitle = title.toLowerCase().trim();
+    const existing = titleMap.get(normalizedTitle) ?? [];
+    existing.push(page.filePath);
+    titleMap.set(normalizedTitle, existing);
+  }
+  const results = [];
+  for (const [title, files] of titleMap) {
+    if (files.length <= 1) continue;
+    for (const file of files) {
+      results.push({
+        rule: "duplicate-concept",
+        severity: "error",
+        file,
+        message: `Duplicate title "${title}" \u2014 also in ${files.filter((f) => f !== file).join(", ")}`
+      });
+    }
+  }
+  return results;
+}
+async function checkEmptyPages(root) {
+  const pages = await collectAllPages(root);
+  const results = [];
+  for (const page of pages) {
+    const { meta, body } = parseFrontmatter(page.content);
+    const hasTitle = typeof meta.title === "string" && meta.title.trim() !== "";
+    const isBodyEmpty = body.trim().length < MIN_BODY_LENGTH;
+    if (hasTitle && isBodyEmpty) {
+      results.push({
+        rule: "empty-page",
+        severity: "warning",
+        file: page.filePath,
+        message: `Page body is empty or too short (< ${MIN_BODY_LENGTH} chars)`
+      });
+    }
+  }
+  return results;
+}
+function stripSpanSuffix(entry) {
+  const colonIdx = entry.indexOf(":");
+  const hashIdx = entry.indexOf("#");
+  const cuts = [colonIdx, hashIdx].filter((i) => i >= 0);
+  if (cuts.length === 0) return entry;
+  return entry.slice(0, Math.min(...cuts));
+}
+async function checkLowConfidencePages(root) {
+  const pages = await collectAllPages(root);
+  const results = [];
+  for (const page of pages) {
+    const { meta } = parseFrontmatter(page.content);
+    const { confidence } = parseProvenanceMetadata(meta);
+    if (confidence === void 0 || confidence >= LOW_CONFIDENCE_THRESHOLD) continue;
+    results.push({
+      rule: "low-confidence",
+      severity: "warning",
+      file: page.filePath,
+      message: `Page confidence ${confidence.toFixed(2)} is below ${LOW_CONFIDENCE_THRESHOLD}`
+    });
+  }
+  return results;
+}
+async function checkContradictedPages(root) {
+  const pages = await collectAllPages(root);
+  const results = [];
+  for (const page of pages) {
+    const { meta } = parseFrontmatter(page.content);
+    const { contradictedBy } = parseProvenanceMetadata(meta);
+    if (!contradictedBy || contradictedBy.length === 0) continue;
+    const slugs = contradictedBy.map((r) => r.slug).join(", ");
+    results.push({
+      rule: "contradicted-page",
+      severity: "warning",
+      file: page.filePath,
+      message: `Page contradicts: ${slugs}`
+    });
+  }
+  return results;
+}
+async function checkInferredWithoutCitations(root) {
+  const pages = await collectAllPages(root);
+  const results = [];
+  for (const page of pages) {
+    const { meta, body } = parseFrontmatter(page.content);
+    const provenance = parseProvenanceMetadata(meta);
+    const inferred = provenance.inferredParagraphs ?? countUncitedProseParagraphs(body);
+    if (inferred <= MAX_INFERRED_PARAGRAPHS_WITHOUT_CITATIONS) continue;
+    results.push({
+      rule: "excess-inferred-paragraphs",
+      severity: "warning",
+      file: page.filePath,
+      message: `Page has ${inferred} inferred paragraphs without citations (max ${MAX_INFERRED_PARAGRAPHS_WITHOUT_CITATIONS})`
+    });
+  }
+  return results;
+}
+var PROSE_PARAGRAPH_LEAD = /^[A-Za-z]/;
+function countUncitedProseParagraphs(body) {
+  const paragraphs = body.split(/\n\s*\n/);
+  let count = 0;
+  for (const block of paragraphs) {
+    const trimmed = block.trim();
+    if (trimmed.length === 0) continue;
+    if (!PROSE_PARAGRAPH_LEAD.test(trimmed)) continue;
+    if (CITATION_PATTERN.test(trimmed)) {
+      CITATION_PATTERN.lastIndex = 0;
+      continue;
+    }
+    CITATION_PATTERN.lastIndex = 0;
+    count += 1;
+  }
+  return count;
+}
+var COLON_SPAN_PATTERN = /^[^:#]+:(\d+)(?:-(\d+))?$/;
+var HASH_SPAN_PATTERN = /^[^:#]+#L(\d+)(?:-L(\d+))?$/;
+async function checkSchemaCrossLinks(root, schema) {
+  const pages = await collectAllPages(root);
+  const results = [];
+  for (const page of pages) {
+    const { meta, body } = parseFrontmatter(page.content);
+    const kind = resolvePageKind(meta.kind, schema);
+    const rule = schema.kinds[kind];
+    if (rule.minWikilinks <= 0) continue;
+    const linkCount = countWikilinks(body);
+    if (linkCount >= rule.minWikilinks) continue;
+    results.push({
+      rule: "schema-cross-link-minimum",
+      severity: "warning",
+      file: page.filePath,
+      message: `Page kind "${kind}" requires at least ${rule.minWikilinks} [[wikilinks]] but only ${linkCount} found.`
+    });
+  }
+  return results;
+}
+function checkPageCrossLinks(content, filePath, schema) {
+  const { meta, body } = parseFrontmatter(content);
+  const kind = resolvePageKind(meta.kind, schema);
+  const rule = schema.kinds[kind];
+  if (rule.minWikilinks <= 0) return [];
+  const linkCount = countWikilinks(body);
+  if (linkCount >= rule.minWikilinks) return [];
+  return [
+    {
+      rule: "schema-cross-link-minimum",
+      severity: "warning",
+      file: filePath,
+      message: `Page kind "${kind}" requires at least ${rule.minWikilinks} [[wikilinks]] but only ${linkCount} found.`
+    }
+  ];
+}
+function parseLineRange(entry) {
+  const colonMatch = COLON_SPAN_PATTERN.exec(entry);
+  if (colonMatch) {
+    const start = Number(colonMatch[1]);
+    const end = colonMatch[2] !== void 0 ? Number(colonMatch[2]) : start;
+    return { start, end };
+  }
+  const hashMatch = HASH_SPAN_PATTERN.exec(entry);
+  if (hashMatch) {
+    const start = Number(hashMatch[1]);
+    const end = hashMatch[2] !== void 0 ? Number(hashMatch[2]) : start;
+    return { start, end };
+  }
+  return null;
+}
+function countLines(content) {
+  if (content.length === 0) return 0;
+  return content.split("\n").length;
+}
+async function checkBrokenCitations(root) {
+  const pages = await collectAllPages(root);
+  const sourcesDir = path16.join(root, SOURCES_DIR);
+  const results = [];
+  const lineCountCache = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    for (const { captured, line } of findMatchesInContent(page.content, CITATION_PATTERN)) {
+      await collectBrokenForMarker(captured, line, page.filePath, sourcesDir, lineCountCache, results);
+    }
+  }
+  return results;
+}
+async function collectBrokenForMarker(captured, line, pageFile, sourcesDir, lineCountCache, out) {
+  for (const part of captured.split(",")) {
+    const trimmed = part.trim();
+    if (trimmed.length === 0) continue;
+    const filename = stripSpanSuffix(trimmed);
+    const citedPath = path16.join(sourcesDir, filename);
+    if (!existsSync6(citedPath)) {
+      out.push({
+        rule: "broken-citation",
+        severity: "error",
+        file: pageFile,
+        message: `Broken citation ^[${filename}] \u2014 source file not found`,
+        line
+      });
+      continue;
+    }
+    const range = parseLineRange(trimmed);
+    if (range === null) continue;
+    const lineCount = await resolveLineCount(citedPath, filename, lineCountCache);
+    if (range.end <= lineCount) continue;
+    out.push({
+      rule: "broken-citation",
+      severity: "error",
+      file: pageFile,
+      message: `Claim-level span ^[${trimmed}] is out of bounds (source has only ${lineCount} lines)`,
+      line
+    });
+  }
+}
+async function resolveLineCount(citedPath, filename, cache) {
+  const cached = cache.get(filename);
+  if (cached !== void 0) return cached;
+  const content = await safeReadFile(citedPath);
+  const lineCount = countLines(content);
+  cache.set(filename, lineCount);
+  return lineCount;
+}
+async function checkMalformedClaimCitations(root) {
+  const pages = await collectAllPages(root);
+  const results = [];
+  for (const page of pages) {
+    for (const { captured, line } of findMatchesInContent(page.content, CITATION_PATTERN)) {
+      for (const part of captured.split(",")) {
+        if (!isMalformedCitationEntry(part)) continue;
+        results.push({
+          rule: "malformed-claim-citation",
+          severity: "error",
+          file: page.filePath,
+          message: `Malformed claim citation ^[${captured}] \u2014 expected file.md, file.md:N-N, or file.md#LN-LN`,
+          line
+        });
+      }
+    }
+  }
+  return results;
+}
+
+// src/compiler/page-renderer.ts
+import { readdir as readdir8 } from "fs/promises";
+import path17 from "path";
+
+// src/compiler/provenance.ts
+function addProvenanceMeta(fields, concept) {
+  if (typeof concept.confidence === "number") {
+    fields.confidence = concept.confidence;
+  }
+  if (concept.provenanceState) {
+    fields.provenanceState = concept.provenanceState;
+  }
+  if (concept.contradictedBy && concept.contradictedBy.length > 0) {
+    fields.contradictedBy = concept.contradictedBy;
+  }
+  if (typeof concept.inferredParagraphs === "number") {
+    fields.inferredParagraphs = concept.inferredParagraphs;
+  }
+}
+function reportContradictionWarnings(conceptTitle, concept) {
+  const refs = concept.contradictedBy;
+  if (!refs || refs.length === 0) return;
+  const slugs = refs.map((r) => r.slug).join(", ");
+  status(
+    "!",
+    warn(`Contradiction reported on "${conceptTitle}" \u2014 conflicts with: ${slugs}`)
+  );
+}
+
+// src/compiler/page-renderer.ts
+var RELATED_PAGE_CONTEXT_LIMIT = 5;
+async function renderMergedPageContent(root, entry, schema) {
+  const pagePath = path17.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
+  const existingPage = await safeReadFile(pagePath);
+  const relatedPages = await loadRelatedPages(root, entry.slug);
+  const system = buildPagePrompt(
+    entry.concept.concept,
+    entry.combinedContent,
+    existingPage,
+    relatedPages
+  );
+  const pageBody = await callClaude({
+    system,
+    messages: [
+      { role: "user", content: `Write the wiki page for "${entry.concept.concept}".` }
+    ]
+  });
+  const frontmatter = buildMergedFrontmatter(entry, existingPage, schema);
+  reportContradictionWarnings(entry.concept.concept, entry.concept);
+  return `${frontmatter}
+
+${pageBody}
+`;
+}
+function buildMergedFrontmatter(entry, existingPage, schema) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = existingPage ? parseFrontmatter(existingPage) : null;
+  const createdAt = existing?.meta.createdAt && typeof existing.meta.createdAt === "string" ? existing.meta.createdAt : now;
+  const frontmatterFields = {
+    title: entry.concept.concept,
+    summary: entry.concept.summary,
+    sources: entry.sourceFiles,
+    kind: schema.defaultKind,
+    createdAt,
+    updatedAt: now
+  };
+  addObsidianMeta(frontmatterFields, entry.concept.concept, entry.concept.tags ?? []);
+  addProvenanceMeta(frontmatterFields, entry.concept);
+  return buildFrontmatter(frontmatterFields);
+}
+async function loadRelatedPages(root, excludeSlug) {
+  const conceptsPath = path17.join(root, CONCEPTS_DIR);
+  let files;
+  try {
+    files = await readdir8(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(path17.join(conceptsPath, f));
+    if (!content) continue;
+    const { meta } = parseFrontmatter(content);
+    if (meta.orphaned) continue;
+    contents.push(content);
+  }
+  return contents.join("\n\n---\n\n");
+}
+
+// src/compiler/index.ts
+import pLimit from "p-limit";
+function emptyCompileResult() {
+  return { compiled: 0, skipped: 0, deleted: 0, concepts: [], pages: [], errors: [] };
+}
+async function compile(root, options = {}) {
+  await compileAndReport(root, options);
+}
+async function compileAndReport(root, options = {}) {
+  header("llmwiki compile");
+  const locked = await acquireLock(root);
+  if (!locked) {
+    status("!", error("Could not acquire lock. Try again later."));
+    return {
+      ...emptyCompileResult(),
+      errors: ["Could not acquire .llmwiki/lock \u2014 another compile is in progress."]
+    };
+  }
+  try {
+    return await runCompilePipeline(root, options);
+  } finally {
+    await releaseLock(root);
+  }
+}
+function bucketChanges(changes) {
+  return {
+    toCompile: changes.filter((c) => c.status === "new" || c.status === "changed"),
+    deleted: changes.filter((c) => c.status === "deleted"),
+    unchanged: changes.filter((c) => c.status === "unchanged")
+  };
+}
+async function generatePagesPhase(root, extractions, frozenSlugs, schema, options) {
+  const merged = mergeExtractions(extractions, frozenSlugs);
+  const sourceStates = options.review ? await buildExtractionSourceStates(root, extractions) : {};
+  const limit = pLimit(COMPILE_CONCURRENCY);
+  const errors = [];
+  const candidates = [];
+  const pages = await Promise.all(
+    merged.map((entry) => limit(async () => {
+      const result = await generateMergedPage(root, entry, schema, options, sourceStates);
+      if (result.error) errors.push(result.error);
+      if (result.candidateId) candidates.push(result.candidateId);
+      return entry;
+    }))
+  );
+  return { pages, errors, candidates };
+}
+async function persistExtractionStates(root, extractions) {
+  for (const result of extractions) {
+    if (result.concepts.length === 0) continue;
+    await persistSourceState(root, result.sourcePath, result.sourceFile, result.concepts);
+  }
+}
+function summarizeCompile(buckets, generation, extractions, options) {
+  header("Compilation complete");
+  status("\u2713", success(
     `${buckets.toCompile.length} compiled, ${buckets.unchanged.length} skipped, ${buckets.deleted.length} deleted`
   ));
   if (options.review && generation.candidates.length > 0) {
@@ -2016,12 +2560,24 @@ function summarizeCompile(buckets, generation, extractions, options) {
   return baseResult;
 }
 async function runCompilePipeline(root, options) {
+  const schema = await loadSchema(root);
+  reportSchemaStatus(schema);
   const state = await readState(root);
   const changes = await detectChanges(root, state);
   augmentWithAffectedSources(changes, findAffectedSources(state, changes));
   const buckets = bucketChanges(changes);
   if (buckets.toCompile.length === 0 && buckets.deleted.length === 0) {
     status("\u2713", success("Nothing to compile \u2014 all sources up to date."));
+    if (!options.review) {
+      const emptyGeneration = { pages: [], errors: [], candidates: [] };
+      await generateSeedPages(root, schema, emptyGeneration);
+      await finalizeWiki(root, emptyGeneration.pages);
+      return {
+        ...emptyCompileResult(),
+        skipped: buckets.unchanged.length,
+        errors: emptyGeneration.errors
+      };
+    }
     return { ...emptyCompileResult(), skipped: buckets.unchanged.length };
   }
   printChangesSummary(changes);
@@ -2034,17 +2590,23 @@ async function runCompilePipeline(root, options) {
   if (!options.review) {
     await freezeFailedExtractions(root, extractions, frozenSlugs);
   }
-  const generation = await generatePagesPhase(root, extractions, frozenSlugs, options);
+  const generation = await generatePagesPhase(root, extractions, frozenSlugs, schema, options);
   if (!options.review) {
     await persistExtractionStates(root, extractions);
     if (frozenSlugs.size > 0) {
       await orphanUnownedFrozenPages(root, frozenSlugs);
     }
     await persistFrozenSlugs(root, frozenSlugs, extractions);
+    await generateSeedPages(root, schema, generation);
     await finalizeWiki(root, generation.pages);
   }
   return summarizeCompile(buckets, generation, extractions, options);
 }
+function reportSchemaStatus(schema) {
+  if (schema.loadedFrom) {
+    status("i", dim(`Schema: ${schema.loadedFrom}`));
+  }
+}
 function augmentWithAffectedSources(changes, affected) {
   for (const file of affected) {
     status("~", info(`${file} [affected by shared concept]`));
@@ -2105,9 +2667,9 @@ function printChangesSummary(changes) {
 }
 async function extractForSource(root, sourceFile) {
   status("*", info(`Extracting: ${sourceFile}`));
-  const sourcePath = path16.join(root, SOURCES_DIR, sourceFile);
-  const sourceContent = await readFile8(sourcePath, "utf-8");
-  const existingIndex = await safeReadFile(path16.join(root, INDEX_FILE));
+  const sourcePath = path18.join(root, SOURCES_DIR, sourceFile);
+  const sourceContent = await readFile10(sourcePath, "utf-8");
+  const existingIndex = await safeReadFile(path18.join(root, INDEX_FILE));
   const concepts = await extractConcepts(sourceContent, existingIndex);
   if (concepts.length > 0) {
     const names = concepts.map((c) => c.concept).join(", ");
@@ -2165,27 +2727,77 @@ ${result.sourceContent}`
   }
   return Array.from(bySlug.values());
 }
-async function generateMergedPage(root, entry, options, sourceStates) {
-  const fullPage = await renderMergedPageContent(root, entry);
+async function generateMergedPage(root, entry, schema, options, sourceStates) {
+  const fullPage = await renderMergedPageContent(root, entry, schema);
   if (options.review) {
-    return await persistReviewCandidate(root, entry, fullPage, sourceStates);
+    return await persistReviewCandidate(root, entry, fullPage, sourceStates, schema);
   }
-  const pagePath = path16.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
+  const pagePath = path18.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
   const error2 = await writePageIfValid(pagePath, fullPage, entry.concept.concept);
   return { error: error2 ?? void 0 };
 }
-async function persistReviewCandidate(root, entry, fullPage, sourceStates) {
+async function persistReviewCandidate(root, entry, fullPage, sourceStates, schema) {
+  const virtualPath = `wiki/concepts/${entry.slug}.md`;
+  const violations = checkPageCrossLinks(fullPage, virtualPath, schema);
   const candidate = await writeCandidate(root, {
     title: entry.concept.concept,
     slug: entry.slug,
     summary: entry.concept.summary,
     sources: entry.sourceFiles,
     body: fullPage,
-    sourceStates: pickStatesForSources(sourceStates, entry.sourceFiles)
+    sourceStates: pickStatesForSources(sourceStates, entry.sourceFiles),
+    schemaViolations: violations.length > 0 ? violations : void 0
   });
   status("?", info(`Candidate ready: ${candidate.id} (${entry.slug})`));
   return { candidateId: candidate.id };
 }
+async function generateSeedPages(root, schema, generation) {
+  if (schema.seedPages.length === 0) return;
+  for (const seed of schema.seedPages) {
+    const error2 = await generateSingleSeedPage(root, schema, seed);
+    if (error2) generation.errors.push(error2);
+  }
+}
+async function generateSingleSeedPage(root, schema, seed) {
+  const slug = slugify(seed.title);
+  const pagePath = path18.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);
+  const pageBody = await callClaude({
+    system,
+    messages: [{ role: "user", content: `Write the ${seed.kind} page titled "${seed.title}".` }]
+  });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await safeReadFile(pagePath);
+  const existingMeta = existing ? parseFrontmatter(existing).meta : null;
+  const createdAt = typeof existingMeta?.createdAt === "string" ? existingMeta.createdAt : now;
+  const typedFields = {
+    title: seed.title,
+    summary: seed.summary,
+    sources: [],
+    kind: seed.kind,
+    createdAt,
+    updatedAt: now
+  };
+  const frontmatterFields = { ...typedFields };
+  addObsidianMeta(frontmatterFields, seed.title, []);
+  const frontmatter = buildFrontmatter(frontmatterFields);
+  return await writePageIfValid(pagePath, `${frontmatter}
+
+${pageBody}
+`, seed.title);
+}
+async function loadSeedRelatedPages(root, slugs) {
+  if (slugs.length === 0) return "";
+  const contents = [];
+  for (const slug of slugs) {
+    const pagePath = path18.join(root, CONCEPTS_DIR, `${slug}.md`);
+    const content = await safeReadFile(pagePath);
+    if (content) contents.push(content);
+  }
+  return contents.join("\n\n---\n\n");
+}
 async function extractConcepts(sourceContent, existingIndex) {
   const system = buildExtractionPrompt(sourceContent, existingIndex);
   const rawOutput = await callClaude({
@@ -2223,7 +2835,7 @@ async function persistSourceState(root, sourcePath, sourceFile, concepts) {
 
 // src/commands/compile.ts
 async function compileCommand(options = {}) {
-  if (!existsSync5(SOURCES_DIR)) {
+  if (!existsSync7(SOURCES_DIR)) {
     status(
       "!",
       warn("No sources found. Run `llmwiki ingest <url>` first.")
@@ -2234,8 +2846,8 @@ async function compileCommand(options = {}) {
 }
 
 // src/commands/query.ts
-import { existsSync as existsSync6 } from "fs";
-import path17 from "path";
+import { existsSync as existsSync8 } from "fs";
+import path19 from "path";
 var PAGE_DIRS = [CONCEPTS_DIR, QUERIES_DIR];
 var PAGE_SELECTION_TOOL = {
   name: "select_pages",
@@ -2290,7 +2902,7 @@ async function selectRelevantPages(root, question) {
     const { pages: rawPages2, reasoning: reasoning2 } = await selectPages(question, filteredIndex);
     return { pages: rawPages2, rawPages: rawPages2, reasoning: reasoning2 };
   }
-  const indexContent = await safeReadFile(path17.join(root, INDEX_FILE));
+  const indexContent = await safeReadFile(path19.join(root, INDEX_FILE));
   const { pages: rawPages, reasoning } = await selectPages(question, indexContent);
   return { pages: rawPages.map((p) => slugify(p)), rawPages, reasoning };
 }
@@ -2308,7 +2920,7 @@ async function loadSelectedPages(root, slugs) {
   for (const slug of slugs) {
     let content = "";
     for (const dir of PAGE_DIRS) {
-      const candidate = await safeReadFile(path17.join(root, dir, `${slug}.md`));
+      const candidate = await safeReadFile(path19.join(root, dir, `${slug}.md`));
       if (!candidate) continue;
       const { meta } = parseFrontmatter(candidate);
       if (meta.orphaned) continue;
@@ -2344,7 +2956,7 @@ function summarizeAnswer(answer) {
 }
 async function saveQueryPage(root, question, answer) {
   const slug = slugify(question);
-  const filePath = path17.join(root, QUERIES_DIR, `${slug}.md`);
+  const filePath = path19.join(root, QUERIES_DIR, `${slug}.md`);
   const frontmatter = buildFrontmatter({
     title: question,
     summary: summarizeAnswer(answer),
@@ -2370,7 +2982,7 @@ ${answer}
   return slug;
 }
 async function generateAnswer(root, question, options = {}) {
-  if (!existsSync6(path17.join(root, INDEX_FILE))) {
+  if (!existsSync8(path19.join(root, INDEX_FILE))) {
     throw new Error("Wiki index not found. Run `llmwiki compile` first.");
   }
   const { pages, reasoning } = await selectRelevantPages(root, question);
@@ -2387,7 +2999,7 @@ async function generateAnswer(root, question, options = {}) {
   return { answer, selectedPages: pages, reasoning, saved };
 }
 async function queryCommand(root, question, options) {
-  if (!existsSync6(path17.join(root, INDEX_FILE))) {
+  if (!existsSync8(path19.join(root, INDEX_FILE))) {
     status("!", error("Wiki index not found. Run `llmwiki compile` first."));
     return;
   }
@@ -2415,12 +3027,12 @@ async function queryCommand(root, question, options) {
 
 // src/commands/watch.ts
 import { watch as chokidarWatch } from "chokidar";
-import { existsSync as existsSync7 } from "fs";
-import path18 from "path";
+import { existsSync as existsSync9 } from "fs";
+import path20 from "path";
 var DEBOUNCE_MS = 500;
 async function watchCommand() {
-  const sourcesPath = path18.resolve(SOURCES_DIR);
-  if (!existsSync7(sourcesPath)) {
+  const sourcesPath = path20.resolve(SOURCES_DIR);
+  if (!existsSync9(sourcesPath)) {
     status(
       "!",
       warn("No sources/ directory found. Run `llmwiki ingest <url>` first.")
@@ -2454,7 +3066,7 @@ async function watchCommand() {
   const scheduleCompile = (eventPath, event) => {
     status(
       "~",
-      dim(`${event}: ${path18.basename(eventPath)}`)
+      dim(`${event}: ${path20.basename(eventPath)}`)
     );
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(triggerCompile, DEBOUNCE_MS);
@@ -2468,261 +3080,30 @@ async function watchCommand() {
   });
 }
 
-// src/linter/rules.ts
-import { readdir as readdir8, readFile as readFile9 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import path19 from "path";
-var MIN_BODY_LENGTH = 50;
-var WIKILINK_PATTERN = /\[\[([^\]]+)\]\]/g;
-var CITATION_PATTERN = /\^\[([^\]]+)\]/g;
-function findMatchesInContent(content, pattern) {
-  const results = [];
-  const lines = content.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const matches = lines[i].matchAll(pattern);
-    for (const match of matches) {
-      results.push({ captured: match[1], line: i + 1 });
-    }
-  }
-  return results;
-}
-async function readMarkdownFiles(dirPath) {
-  if (!existsSync8(dirPath)) return [];
-  const entries = await readdir8(dirPath);
-  const mdFiles = entries.filter((f) => f.endsWith(".md"));
-  const results = await Promise.all(
-    mdFiles.map(async (fileName) => {
-      const filePath = path19.join(dirPath, fileName);
-      const content = await readFile9(filePath, "utf-8");
-      return { filePath, content };
-    })
-  );
-  return results;
-}
-async function collectAllPages(root) {
-  const conceptPages = await readMarkdownFiles(path19.join(root, CONCEPTS_DIR));
-  const queryPages = await readMarkdownFiles(path19.join(root, QUERIES_DIR));
-  return [...conceptPages, ...queryPages];
-}
-function buildPageSlugSet(pages) {
-  const slugs = /* @__PURE__ */ new Set();
-  for (const page of pages) {
-    const baseName = path19.basename(page.filePath, ".md");
-    slugs.add(baseName.toLowerCase());
-  }
-  return slugs;
-}
-async function checkBrokenWikilinks(root) {
-  const pages = await collectAllPages(root);
-  const existingSlugs = buildPageSlugSet(pages);
-  const results = [];
-  for (const page of pages) {
-    for (const { captured, line } of findMatchesInContent(page.content, WIKILINK_PATTERN)) {
-      const linkSlug = slugify(captured);
-      if (!existingSlugs.has(linkSlug)) {
-        results.push({
-          rule: "broken-wikilink",
-          severity: "error",
-          file: page.filePath,
-          message: `Broken wikilink [[${captured}]] \u2014 no matching page found`,
-          line
-        });
-      }
-    }
-  }
-  return results;
-}
-async function checkOrphanedPages(root) {
-  const pages = await collectAllPages(root);
-  const results = [];
-  for (const page of pages) {
-    const { meta } = parseFrontmatter(page.content);
-    if (meta.orphaned === true) {
-      results.push({
-        rule: "orphaned-page",
-        severity: "warning",
-        file: page.filePath,
-        message: `Page is marked as orphaned`
-      });
-    }
-  }
-  return results;
-}
-async function checkMissingSummaries(root) {
-  const pages = await collectAllPages(root);
-  const results = [];
-  for (const page of pages) {
-    const { meta } = parseFrontmatter(page.content);
-    const summary = meta.summary;
-    const isMissing = !summary || typeof summary === "string" && summary.trim() === "";
-    if (isMissing) {
-      results.push({
-        rule: "missing-summary",
-        severity: "warning",
-        file: page.filePath,
-        message: `Page has no summary in frontmatter`
-      });
-    }
-  }
-  return results;
-}
-async function checkDuplicateConcepts(root) {
-  const pages = await collectAllPages(root);
-  const titleMap = /* @__PURE__ */ new Map();
-  for (const page of pages) {
-    const { meta } = parseFrontmatter(page.content);
-    const title = typeof meta.title === "string" ? meta.title : "";
-    if (!title) continue;
-    const normalizedTitle = title.toLowerCase().trim();
-    const existing = titleMap.get(normalizedTitle) ?? [];
-    existing.push(page.filePath);
-    titleMap.set(normalizedTitle, existing);
-  }
-  const results = [];
-  for (const [title, files] of titleMap) {
-    if (files.length <= 1) continue;
-    for (const file of files) {
-      results.push({
-        rule: "duplicate-concept",
-        severity: "error",
-        file,
-        message: `Duplicate title "${title}" \u2014 also in ${files.filter((f) => f !== file).join(", ")}`
-      });
-    }
-  }
-  return results;
-}
-async function checkEmptyPages(root) {
-  const pages = await collectAllPages(root);
-  const results = [];
-  for (const page of pages) {
-    const { meta, body } = parseFrontmatter(page.content);
-    const hasTitle = typeof meta.title === "string" && meta.title.trim() !== "";
-    const isBodyEmpty = body.trim().length < MIN_BODY_LENGTH;
-    if (hasTitle && isBodyEmpty) {
-      results.push({
-        rule: "empty-page",
-        severity: "warning",
-        file: page.filePath,
-        message: `Page body is empty or too short (< ${MIN_BODY_LENGTH} chars)`
-      });
-    }
-  }
-  return results;
-}
-async function checkLowConfidencePages(root) {
-  const pages = await collectAllPages(root);
-  const results = [];
-  for (const page of pages) {
-    const { meta } = parseFrontmatter(page.content);
-    const { confidence } = parseProvenanceMetadata(meta);
-    if (confidence === void 0 || confidence >= LOW_CONFIDENCE_THRESHOLD) continue;
-    results.push({
-      rule: "low-confidence",
-      severity: "warning",
-      file: page.filePath,
-      message: `Page confidence ${confidence.toFixed(2)} is below ${LOW_CONFIDENCE_THRESHOLD}`
-    });
-  }
-  return results;
-}
-async function checkContradictedPages(root) {
-  const pages = await collectAllPages(root);
-  const results = [];
-  for (const page of pages) {
-    const { meta } = parseFrontmatter(page.content);
-    const { contradictedBy } = parseProvenanceMetadata(meta);
-    if (!contradictedBy || contradictedBy.length === 0) continue;
-    const slugs = contradictedBy.map((r) => r.slug).join(", ");
-    results.push({
-      rule: "contradicted-page",
-      severity: "warning",
-      file: page.filePath,
-      message: `Page contradicts: ${slugs}`
-    });
-  }
-  return results;
-}
-async function checkInferredWithoutCitations(root) {
-  const pages = await collectAllPages(root);
-  const results = [];
-  for (const page of pages) {
-    const { meta, body } = parseFrontmatter(page.content);
-    const provenance = parseProvenanceMetadata(meta);
-    const inferred = provenance.inferredParagraphs ?? countUncitedProseParagraphs(body);
-    if (inferred <= MAX_INFERRED_PARAGRAPHS_WITHOUT_CITATIONS) continue;
-    results.push({
-      rule: "excess-inferred-paragraphs",
-      severity: "warning",
-      file: page.filePath,
-      message: `Page has ${inferred} inferred paragraphs without citations (max ${MAX_INFERRED_PARAGRAPHS_WITHOUT_CITATIONS})`
-    });
-  }
-  return results;
-}
-var PROSE_PARAGRAPH_LEAD = /^[A-Za-z]/;
-function countUncitedProseParagraphs(body) {
-  const paragraphs = body.split(/\n\s*\n/);
-  let count = 0;
-  for (const block of paragraphs) {
-    const trimmed = block.trim();
-    if (trimmed.length === 0) continue;
-    if (!PROSE_PARAGRAPH_LEAD.test(trimmed)) continue;
-    if (CITATION_PATTERN.test(trimmed)) {
-      CITATION_PATTERN.lastIndex = 0;
-      continue;
-    }
-    CITATION_PATTERN.lastIndex = 0;
-    count += 1;
-  }
-  return count;
-}
-function splitCitationFilenames(captured) {
-  return captured.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-}
-async function checkBrokenCitations(root) {
-  const pages = await collectAllPages(root);
-  const sourcesDir = path19.join(root, SOURCES_DIR);
-  const results = [];
-  for (const page of pages) {
-    for (const { captured, line } of findMatchesInContent(page.content, CITATION_PATTERN)) {
-      for (const filename of splitCitationFilenames(captured)) {
-        const citedPath = path19.join(sourcesDir, filename);
-        if (!existsSync8(citedPath)) {
-          results.push({
-            rule: "broken-citation",
-            severity: "error",
-            file: page.filePath,
-            message: `Broken citation ^[${filename}] \u2014 source file not found`,
-            line
-          });
-        }
-      }
-    }
-  }
-  return results;
-}
-
 // src/linter/index.ts
-var ALL_RULES = [
+var RULES_WITHOUT_SCHEMA = [
   checkBrokenWikilinks,
   checkOrphanedPages,
   checkMissingSummaries,
   checkDuplicateConcepts,
   checkEmptyPages,
   checkBrokenCitations,
+  checkMalformedClaimCitations,
   checkLowConfidencePages,
   checkContradictedPages,
   checkInferredWithoutCitations
 ];
+var RULES_WITH_SCHEMA = [checkSchemaCrossLinks];
 function countBySeverity(results, severity) {
   return results.filter((r) => r.severity === severity).length;
 }
 async function lint(root) {
-  const ruleResults = await Promise.all(
-    ALL_RULES.map((rule) => rule(root))
-  );
-  const results = ruleResults.flat();
+  const schema = await loadSchema(root);
+  const [plainResults, schemaResults] = await Promise.all([
+    Promise.all(RULES_WITHOUT_SCHEMA.map((rule) => rule(root))),
+    Promise.all(RULES_WITH_SCHEMA.map((rule) => rule(root, schema)))
+  ]);
+  const results = [...plainResults.flat(), ...schemaResults.flat()];
   return {
     errors: countBySeverity(results, "error"),
     warnings: countBySeverity(results, "warning"),
@@ -2750,6 +3131,9 @@ function printResult(result) {
 }
 async function lintCommand() {
   header("Linting wiki");
+  const schema = await loadSchema(process.cwd());
+  const schemaSource = schema.loadedFrom ?? "defaults (no schema file)";
+  status("i", dim(`Schema: ${schemaSource}`));
   const summary = await lint(process.cwd());
   for (const result of summary.results) {
     printResult(result);
@@ -2766,6 +3150,36 @@ async function lintCommand() {
   }
 }
 
+// src/commands/schema.ts
+import { existsSync as existsSync10 } from "fs";
+import { mkdir as mkdir6, writeFile as writeFile5 } from "fs/promises";
+import path21 from "path";
+async function schemaInitCommand() {
+  const root = process.cwd();
+  const defaults = buildDefaultSchema();
+  const targetPath = defaultSchemaInitPath(root);
+  if (existsSync10(targetPath)) {
+    status("!", warn(`Schema file already exists at ${targetPath}`));
+    return;
+  }
+  await mkdir6(path21.dirname(targetPath), { recursive: true });
+  const serializable = {
+    version: defaults.version,
+    defaultKind: defaults.defaultKind,
+    kinds: defaults.kinds,
+    seedPages: defaults.seedPages
+  };
+  await writeFile5(targetPath, `${JSON.stringify(serializable, null, 2)}
+`, "utf-8");
+  status("+", success(`Wrote schema to ${targetPath}`));
+}
+async function schemaShowCommand() {
+  const schema = await loadSchema(process.cwd());
+  const loadedFrom = schema.loadedFrom ?? "(defaults \u2014 no schema file found)";
+  header(`Schema (${loadedFrom})`);
+  console.log(serializeSchemaToYaml(schema));
+}
+
 // src/commands/review-list.ts
 async function reviewListCommand() {
   header("Pending review candidates");
@@ -2797,10 +3211,17 @@ async function reviewShowCommand(id) {
   status("i", dim(`generated:  ${candidate.generatedAt}`));
   console.log();
   console.log(candidate.body);
+  if (candidate.schemaViolations && candidate.schemaViolations.length > 0) {
+    console.log();
+    header("Schema violations");
+    for (const v of candidate.schemaViolations) {
+      status("!", warn(`[${v.severity}] ${v.message}`));
+    }
+  }
 }
 
 // src/commands/review-approve.ts
-import path20 from "path";
+import path22 from "path";
 
 // src/commands/review-helpers.ts
 async function runReviewUnderLock(id, underLock) {
@@ -2832,7 +3253,7 @@ async function approveUnderLock(root, id) {
     process.exitCode = 1;
     return;
   }
-  const pagePath = path20.join(root, CONCEPTS_DIR, `${candidate.slug}.md`);
+  const pagePath = path22.join(root, CONCEPTS_DIR, `${candidate.slug}.md`);
   await atomicWrite(pagePath, candidate.body);
   status("+", success(`Approved \u2192 ${source(pagePath)}`));
   await persistCandidateSourceStates(root, candidate);
@@ -2892,7 +3313,7 @@ import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/tools.ts
-import path21 from "path";
+import path23 from "path";
 import { z } from "zod";
 
 // src/mcp/provider-check.ts
@@ -3022,7 +3443,7 @@ async function pickSearchSlugs(root, question) {
     if (candidates.length > 0) return candidates.map((c) => c.slug);
   } catch {
   }
-  const indexContent = await safeReadFile(path21.join(root, INDEX_FILE));
+  const indexContent = await safeReadFile(path23.join(root, INDEX_FILE));
   const { pages } = await selectPages(question, indexContent);
   return pages;
 }
@@ -3071,8 +3492,8 @@ function registerStatusTool(server, root) {
   );
 }
 async function collectStatus(root) {
-  const concepts = await collectPageSummaries(path21.join(root, CONCEPTS_DIR));
-  const queries = await collectPageSummaries(path21.join(root, QUERIES_DIR));
+  const concepts = await collectPageSummaries(path23.join(root, CONCEPTS_DIR));
+  const queries = await collectPageSummaries(path23.join(root, QUERIES_DIR));
   const state = await readState(root);
   const changes = await detectChanges(root, state);
   const orphans = await findOrphanedSlugs(root);
@@ -3089,7 +3510,7 @@ async function collectStatus(root) {
   };
 }
 async function findOrphanedSlugs(root) {
-  const scanned = await scanWikiPages(path21.join(root, CONCEPTS_DIR));
+  const scanned = await scanWikiPages(path23.join(root, CONCEPTS_DIR));
   return scanned.filter(({ meta }) => meta.orphaned).map(({ slug }) => slug);
 }
 async function loadPageRecords(root, slugs) {
@@ -3102,7 +3523,7 @@ async function loadPageRecords(root, slugs) {
 }
 async function readPage(root, slug) {
   for (const dir of PAGE_DIRS2) {
-    const content = await safeReadFile(path21.join(root, dir, `${slug}.md`));
+    const content = await safeReadFile(path23.join(root, dir, `${slug}.md`));
     if (!content) continue;
     const { meta, body } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -3117,7 +3538,7 @@ async function readPage(root, slug) {
 }
 
 // src/mcp/resources.ts
-import path22 from "path";
+import path24 from "path";
 import { readdir as readdir9 } from "fs/promises";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 function jsonContent(uri, payload) {
@@ -3151,7 +3572,7 @@ function registerIndexResource(server, root) {
       mimeType: "text/markdown"
     },
     async (uri) => {
-      const content = await safeReadFile(path22.join(root, INDEX_FILE));
+      const content = await safeReadFile(path24.join(root, INDEX_FILE));
       return { contents: [markdownContent(uri, content)] };
     }
   );
@@ -3218,7 +3639,7 @@ function registerQueryResource(server, root) {
   );
 }
 async function listSources(root) {
-  const sourcesPath = path22.join(root, SOURCES_DIR);
+  const sourcesPath = path24.join(root, SOURCES_DIR);
   let files;
   try {
     files = await readdir9(sourcesPath);
@@ -3227,14 +3648,14 @@ async function listSources(root) {
   }
   const records = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path22.join(sourcesPath, file));
+    const content = await safeReadFile(path24.join(sourcesPath, file));
     const { meta } = parseFrontmatter(content);
     records.push({ filename: file, ...meta });
   }
   return records;
 }
 async function loadPageWithMeta(root, dir, slug) {
-  const filePath = path22.join(root, dir, `${slug}.md`);
+  const filePath = path24.join(root, dir, `${slug}.md`);
   const content = await safeReadFile(filePath);
   if (!content) {
     throw new Error(`Page not found: ${dir}/${slug}.md`);
@@ -3243,7 +3664,7 @@ async function loadPageWithMeta(root, dir, slug) {
   return { slug, meta, body: body.trim() };
 }
 async function listPagesUnder(root, dir, scheme) {
-  const pagesPath = path22.join(root, dir);
+  const pagesPath = path24.join(root, dir);
   let files;
   try {
     files = await readdir9(pagesPath);
@@ -3353,6 +3774,23 @@ program.command("lint").description("Run rule-based quality checks against the w
     process.exit(1);
   }
 });
+var schemaCmd = program.command("schema").description("Inspect or initialize the project's wiki schema config");
+schemaCmd.command("init").description("Write a starter schema file to .llmwiki/schema.json").action(async () => {
+  try {
+    await schemaInitCommand();
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+schemaCmd.command("show").description("Print the resolved schema for this project").action(async () => {
+  try {
+    await schemaShowCommand();
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
 program.command("serve").description("Start an MCP server exposing wiki tools and resources over stdio").option("--root <dir>", "Project root directory", process.cwd()).action(async (options) => {
   try {
     await startMCPServer({ root: options.root, version });