llm-wiki-compiler 0.1.1 → 0.2.0

package/dist/cli.js

@@ -66,7 +66,14 @@ var COMPILE_CONCURRENCY = 5;
 var RETRY_COUNT = 3;
 var RETRY_BASE_MS = 1e3;
 var RETRY_MULTIPLIER = 4;
-var MODEL = "claude-sonnet-4-20250514";
+var DEFAULT_PROVIDER = "anthropic";
+var PROVIDER_MODELS = {
+  anthropic: "claude-sonnet-4-20250514",
+  openai: "gpt-4o",
+  ollama: "llama3.1",
+  minimax: "MiniMax-M2.7"
+};
+var OLLAMA_DEFAULT_HOST = "http://localhost:11434/v1";
 var SOURCES_DIR = "sources";
 var CONCEPTS_DIR = "wiki/concepts";
 var QUERIES_DIR = "wiki/queries";
@@ -74,6 +81,14 @@ var LLMWIKI_DIR = ".llmwiki";
 var STATE_FILE = ".llmwiki/state.json";
 var LOCK_FILE = ".llmwiki/lock";
 var INDEX_FILE = "wiki/index.md";
+var MOC_FILE = "wiki/MOC.md";
+var EMBEDDINGS_FILE = ".llmwiki/embeddings.json";
+var EMBEDDING_TOP_K = 15;
+var EMBEDDING_MODELS = {
+  anthropic: "voyage-3-lite",
+  openai: "text-embedding-3-small",
+  ollama: "nomic-embed-text"
+};
 
 // src/utils/output.ts
 var RESET = "\x1B[0m";
@@ -234,26 +249,36 @@ async function saveSource(title, document) {
   await writeFile2(destPath, document, "utf-8");
   return destPath;
 }
-async function ingest(source2) {
+async function ingestSource(source2) {
   status("*", info(`Ingesting: ${source2}`));
   const { title, content } = isUrl(source2) ? await ingestWeb(source2) : await ingestFile(source2);
   const result = enforceCharLimit(content);
   enforceMinContent(result.content);
   const document = buildDocument(title, source2, result);
   const savedPath = await saveSource(title, document);
+  return {
+    filename: path3.basename(savedPath),
+    charCount: result.content.length,
+    truncated: result.truncated,
+    source: source2
+  };
+}
+async function ingest(source2) {
+  const result = await ingestSource(source2);
+  const savedPath = path3.join(SOURCES_DIR, result.filename);
   status(
     "+",
-    success(`Saved ${bold(title)} \u2192 ${source(savedPath)}`)
+    success(`Saved ${bold(result.filename)} \u2192 ${source(savedPath)}`)
   );
   status("\u2192", dim("Next: llmwiki compile"));
 }
 
 // src/commands/compile.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 
 // src/compiler/index.ts
-import { readFile as readFile7, readdir as readdir4 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile8, readdir as readdir6 } from "fs/promises";
+import path13 from "path";
 
 // src/utils/state.ts
 import { readFile as readFile3, writeFile as writeFile3, rename as rename2, mkdir as mkdir3, copyFile } from "fs/promises";
@@ -296,30 +321,387 @@ async function removeSourceState(root, sourceFile) {
   await writeState(root, state);
 }
 
-// src/utils/llm.ts
+// src/providers/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
-var client = null;
-function getClient() {
-  if (!client) {
-    client = new Anthropic();
+var VOYAGE_EMBEDDINGS_URL = "https://api.voyageai.com/v1/embeddings";
+function buildAnthropicClientOptions(options = {}) {
+  const trimmedBaseURL = options.baseURL?.trim();
+  const trimmedApiKey = options.apiKey?.trim();
+  const trimmedAuthToken = options.authToken?.trim();
+  const result = {};
+  if (trimmedApiKey) {
+    result.apiKey = trimmedApiKey;
+  }
+  if (trimmedAuthToken) {
+    result.authToken = trimmedAuthToken;
+  }
+  if (!trimmedBaseURL) {
+    return result;
+  }
+  const normalizedBaseURL = trimmedBaseURL.endsWith("/") && trimmedBaseURL.length > 1 ? trimmedBaseURL.slice(0, -1) : trimmedBaseURL;
+  result.baseURL = normalizedBaseURL;
+  return result;
+}
+var AnthropicProvider = class {
+  client;
+  model;
+  constructor(model, options = {}) {
+    this.model = model;
+    this.client = new Anthropic(buildAnthropicClientOptions(options));
+  }
+  /** Send a single non-streaming completion request. */
+  async complete(system, messages, maxTokens) {
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: maxTokens,
+      system,
+      messages
+    });
+    const textBlock = response.content.find((block) => block.type === "text");
+    return textBlock?.type === "text" ? textBlock.text : "";
+  }
+  /** Stream a completion, invoking onToken for each text chunk. */
+  async stream(system, messages, maxTokens, onToken) {
+    const stream = this.client.messages.stream({
+      model: this.model,
+      max_tokens: maxTokens,
+      system,
+      messages
+    });
+    let fullText = "";
+    for await (const event of stream) {
+      if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+        fullText += event.delta.text;
+        onToken?.(event.delta.text);
+      }
+    }
+    return fullText;
+  }
+  /** Call Claude with tool definitions and return the parsed tool input as JSON. */
+  async toolCall(system, messages, tools, maxTokens) {
+    const anthropicTools = tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.input_schema
+    }));
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: maxTokens,
+      system,
+      messages,
+      tools: anthropicTools
+    });
+    const toolBlock = response.content.find((block) => block.type === "tool_use");
+    if (toolBlock?.type === "tool_use") {
+      return JSON.stringify(toolBlock.input);
+    }
+    const textBlock = response.content.find((block) => block.type === "text");
+    return textBlock?.type === "text" ? textBlock.text : "";
+  }
+  /**
+   * Produce a single embedding vector via the Voyage API.
+   *
+   * Anthropic does not ship a first-party embeddings endpoint, so we delegate
+   * to Voyage (their recommended partner). Requires VOYAGE_API_KEY.
+   */
+  async embed(text) {
+    const apiKey = process.env.VOYAGE_API_KEY?.trim();
+    if (!apiKey) {
+      throw new Error(
+        "VOYAGE_API_KEY is not set. Anthropic embeddings use Voyage \u2014 set VOYAGE_API_KEY to enable semantic search."
+      );
+    }
+    const response = await fetch(VOYAGE_EMBEDDINGS_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ input: text, model: EMBEDDING_MODELS.anthropic })
+    });
+    if (!response.ok) {
+      const detail = await response.text();
+      throw new Error(`Voyage embeddings request failed (${response.status}): ${detail}`);
+    }
+    const json = await response.json();
+    const vector = json.data?.[0]?.embedding;
+    if (!Array.isArray(vector)) {
+      throw new Error("Voyage embeddings response did not include a vector.");
+    }
+    return vector;
+  }
+};
+
+// src/providers/openai.ts
+import OpenAI from "openai";
+function translateToolToOpenAI(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.input_schema
+    }
+  };
+}
+var OpenAIProvider = class {
+  client;
+  model;
+  constructor(model, baseURL, apiKey) {
+    this.model = model;
+    const resolvedKey = apiKey ?? process.env.OPENAI_API_KEY ?? "";
+    this.client = new OpenAI({
+      apiKey: resolvedKey,
+      ...baseURL ? { baseURL } : {}
+    });
+  }
+  /** Send a single non-streaming completion request. */
+  async complete(system, messages, maxTokens) {
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      max_tokens: maxTokens,
+      messages: [{ role: "system", content: system }, ...messages]
+    });
+    return response.choices[0]?.message?.content ?? "";
+  }
+  /** Stream a completion, invoking onToken for each text chunk. */
+  async stream(system, messages, maxTokens, onToken) {
+    const stream = await this.client.chat.completions.create({
+      model: this.model,
+      max_tokens: maxTokens,
+      messages: [{ role: "system", content: system }, ...messages],
+      stream: true
+    });
+    let fullText = "";
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta?.content;
+      if (delta) {
+        fullText += delta;
+        onToken?.(delta);
+      }
+    }
+    return fullText;
+  }
+  /** Call the model with tool definitions and return the parsed tool input as JSON. */
+  async toolCall(system, messages, tools, maxTokens) {
+    const openaiTools = tools.map(translateToolToOpenAI);
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      max_tokens: maxTokens,
+      messages: [{ role: "system", content: system }, ...messages],
+      tools: openaiTools
+    });
+    const toolCalls = response.choices[0]?.message?.tool_calls;
+    if (toolCalls && toolCalls.length > 0) {
+      return toolCalls[0].function.arguments;
+    }
+    return response.choices[0]?.message?.content ?? "";
+  }
+  /**
+   * Produce a single embedding vector via the OpenAI embeddings API.
+   * Subclasses (e.g. Ollama) override embeddingModel() to pick a different model.
+   */
+  async embed(text) {
+    const response = await this.client.embeddings.create({
+      model: this.embeddingModel(),
+      input: text
+    });
+    const vector = response.data[0]?.embedding;
+    if (!Array.isArray(vector)) {
+      throw new Error("OpenAI embeddings response did not include a vector.");
+    }
+    return vector;
+  }
+  /** Default embedding model for this provider. Subclasses may override. */
+  embeddingModel() {
+    return EMBEDDING_MODELS.openai;
+  }
+};
+
+// src/providers/ollama.ts
+var OllamaProvider = class extends OpenAIProvider {
+  constructor(model, baseURL) {
+    super(model, baseURL, "ollama");
+  }
+  /** Ollama ships a dedicated embedding model (nomic-embed-text). */
+  embeddingModel() {
+    return EMBEDDING_MODELS.ollama;
+  }
+};
+
+// src/providers/minimax.ts
+var MINIMAX_BASE_URL = "https://api.minimax.io/v1";
+var MiniMaxProvider = class extends OpenAIProvider {
+  constructor(model, apiKey) {
+    super(model, MINIMAX_BASE_URL, apiKey);
+  }
+};
+
+// src/utils/claude-settings.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import path5 from "path";
+var CLAUDE_SETTINGS_PATH_ENV = "LLMWIKI_CLAUDE_SETTINGS_PATH";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function normalize(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveClaudeSettingsPath(env) {
+  return env[CLAUDE_SETTINGS_PATH_ENV] ?? path5.join(homedir(), ".claude", "settings.json");
+}
+function readClaudeSettingsFile(settingsPath) {
+  try {
+    return readFileSync(settingsPath, "utf8");
+  } catch (err) {
+    if (isRecord(err) && err.code === "ENOENT") {
+      return void 0;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to read Claude settings at "${settingsPath}": ${message}`);
+  }
+}
+function readClaudeSettingsEnv(env = process.env) {
+  const settingsPath = resolveClaudeSettingsPath(env);
+  const raw = readClaudeSettingsFile(settingsPath);
+  if (!raw) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse Claude settings at "${settingsPath}": ${message}`);
+  }
+  if (!isRecord(parsed) || !isRecord(parsed.env)) {
+    return void 0;
   }
-  return client;
+  const values = {
+    ANTHROPIC_API_KEY: normalize(parsed.env.ANTHROPIC_API_KEY),
+    ANTHROPIC_AUTH_TOKEN: normalize(parsed.env.ANTHROPIC_AUTH_TOKEN),
+    ANTHROPIC_BASE_URL: normalize(parsed.env.ANTHROPIC_BASE_URL),
+    ANTHROPIC_MODEL: normalize(parsed.env.ANTHROPIC_MODEL)
+  };
+  if (!values.ANTHROPIC_API_KEY && !values.ANTHROPIC_AUTH_TOKEN && !values.ANTHROPIC_BASE_URL && !values.ANTHROPIC_MODEL) {
+    return void 0;
+  }
+  return values;
+}
+function tryReadClaudeSettingsEnv(env) {
+  try {
+    return readClaudeSettingsEnv(env);
+  } catch {
+    return void 0;
+  }
+}
+function validateAnthropicBaseURL(value) {
+  const normalized = value.trim();
+  try {
+    const parsed = new URL(normalized);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error("Must use http:// or https:// protocol.");
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Must be a valid http(s) URL.";
+    throw new Error(`Invalid ANTHROPIC_BASE_URL: "${normalized}". ${message}`);
+  }
+  return normalized;
+}
+function resolveAnthropicAuthFromEnv(env = process.env) {
+  const explicitApiKey = normalize(env.ANTHROPIC_API_KEY);
+  if (explicitApiKey) return { apiKey: explicitApiKey };
+  const explicitAuthToken = normalize(env.ANTHROPIC_AUTH_TOKEN);
+  if (explicitAuthToken) return { authToken: explicitAuthToken };
+  const fallback = readClaudeSettingsEnv(env);
+  if (fallback?.ANTHROPIC_API_KEY) return { apiKey: fallback.ANTHROPIC_API_KEY };
+  if (fallback?.ANTHROPIC_AUTH_TOKEN) return { authToken: fallback.ANTHROPIC_AUTH_TOKEN };
+  return {};
+}
+function resolveAnthropicModelFromEnv(env = process.env) {
+  const explicitModel = env.LLMWIKI_MODEL;
+  if (explicitModel !== void 0) return explicitModel;
+  return tryReadClaudeSettingsEnv(env)?.ANTHROPIC_MODEL;
+}
+function resolveAnthropicBaseURLFromEnv(env = process.env) {
+  const explicitBaseURL = normalize(env.ANTHROPIC_BASE_URL);
+  if (explicitBaseURL) return validateAnthropicBaseURL(explicitBaseURL);
+  const fallbackBaseURL = tryReadClaudeSettingsEnv(env)?.ANTHROPIC_BASE_URL;
+  if (!fallbackBaseURL) return void 0;
+  return validateAnthropicBaseURL(fallbackBaseURL);
+}
+
+// src/utils/provider.ts
+var SUPPORTED_PROVIDERS = /* @__PURE__ */ new Set(["anthropic", "openai", "ollama", "minimax"]);
+function getProvider() {
+  const providerName = getProviderName();
+  switch (providerName) {
+    case "anthropic":
+      return getAnthropicProvider();
+    case "openai":
+      return new OpenAIProvider(getModelForProvider("openai"));
+    case "ollama":
+      return new OllamaProvider(
+        getModelForProvider("ollama"),
+        process.env.OLLAMA_HOST ?? OLLAMA_DEFAULT_HOST
+      );
+    case "minimax":
+      return getMiniMaxProvider();
+    default:
+      throw new Error(`Unhandled provider: ${providerName}`);
+  }
+}
+function getModelForProvider(providerName) {
+  return process.env.LLMWIKI_MODEL ?? PROVIDER_MODELS[providerName];
+}
+function getMiniMaxProvider() {
+  const apiKey = process.env.MINIMAX_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "MiniMax provider requires MINIMAX_API_KEY environment variable.\n  Set it with: export MINIMAX_API_KEY=your_key"
+    );
+  }
+  return new MiniMaxProvider(getModelForProvider("minimax"), apiKey);
+}
+function getAnthropicProvider() {
+  const model = resolveAnthropicModelFromEnv() ?? PROVIDER_MODELS.anthropic;
+  const baseURL = resolveAnthropicBaseURLFromEnv();
+  const auth = resolveAnthropicAuthFromEnv();
+  return new AnthropicProvider(model, {
+    baseURL,
+    ...auth
+  });
+}
+function getProviderName() {
+  const providerName = process.env.LLMWIKI_PROVIDER ?? DEFAULT_PROVIDER;
+  if (!SUPPORTED_PROVIDERS.has(providerName)) {
+    throw new Error(
+      `Unknown provider "${providerName}". Supported: ${[...SUPPORTED_PROVIDERS].join(", ")}`
+    );
+  }
+  return providerName;
+}
+function getActiveProviderName() {
+  return getProviderName();
 }
+
+// src/utils/llm.ts
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function callClaude(options) {
   const { system, messages, tools, maxTokens = 4096, stream = false, onToken } = options;
-  const anthropic = getClient();
+  const provider = getProvider();
   for (let attempt = 0; attempt <= RETRY_COUNT; attempt++) {
     try {
       if (stream) {
-        return await callClaudeStreaming(anthropic, system, messages, maxTokens, onToken);
+        return await provider.stream(system, messages, maxTokens, onToken);
       }
       if (tools && tools.length > 0) {
-        return await callClaudeToolUse(anthropic, system, messages, tools, maxTokens);
+        return await provider.toolCall(system, messages, tools, maxTokens);
       }
-      return await callClaudeBasic(anthropic, system, messages, maxTokens);
+      return await provider.complete(system, messages, maxTokens);
     } catch (error2) {
       if (attempt === RETRY_COUNT) throw error2;
       const delayMs = RETRY_BASE_MS * Math.pow(RETRY_MULTIPLIER, attempt);
@@ -331,57 +713,10 @@ async function callClaude(options) {
   }
   throw new Error("Unreachable");
 }
-async function callClaudeStreaming(anthropic, system, messages, maxTokens, onToken) {
-  const stream = anthropic.messages.stream({
-    model: MODEL,
-    max_tokens: maxTokens,
-    system,
-    messages
-  });
-  let fullText = "";
-  for await (const event of stream) {
-    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
-      fullText += event.delta.text;
-      onToken?.(event.delta.text);
-    }
-  }
-  return fullText;
-}
-async function callClaudeToolUse(anthropic, system, messages, tools, maxTokens) {
-  const response = await anthropic.messages.create({
-    model: MODEL,
-    max_tokens: maxTokens,
-    system,
-    messages,
-    tools
-  });
-  const toolBlock = response.content.find((block) => block.type === "tool_use");
-  if (toolBlock && toolBlock.type === "tool_use") {
-    return JSON.stringify(toolBlock.input);
-  }
-  const textBlock = response.content.find((block) => block.type === "text");
-  if (textBlock && textBlock.type === "text") {
-    return textBlock.text;
-  }
-  return "";
-}
-async function callClaudeBasic(anthropic, system, messages, maxTokens) {
-  const response = await anthropic.messages.create({
-    model: MODEL,
-    max_tokens: maxTokens,
-    system,
-    messages
-  });
-  const textBlock = response.content.find((block) => block.type === "text");
-  if (textBlock && textBlock.type === "text") {
-    return textBlock.text;
-  }
-  return "";
-}
 
 // src/utils/lock.ts
 import { open, readFile as readFile4, unlink, mkdir as mkdir4 } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 var RECLAIM_SUFFIX = ".reclaim";
 var MAX_ACQUIRE_ATTEMPTS = 2;
 function isProcessAlive(pid) {
@@ -393,8 +728,8 @@ function isProcessAlive(pid) {
   }
 }
 async function acquireLock(root) {
-  const lockPath = path5.join(root, LOCK_FILE);
-  await mkdir4(path5.join(root, LLMWIKI_DIR), { recursive: true });
+  const lockPath = path6.join(root, LOCK_FILE);
+  await mkdir4(path6.join(root, LLMWIKI_DIR), { recursive: true });
   for (let attempt = 0; attempt < MAX_ACQUIRE_ATTEMPTS; attempt++) {
     const created = await tryCreateLock(lockPath);
     if (created) return true;
@@ -466,7 +801,7 @@ async function isLockStale(lockPath) {
   }
 }
 async function releaseLock(root) {
-  const lockPath = path5.join(root, LOCK_FILE);
+  const lockPath = path6.join(root, LOCK_FILE);
   try {
     await unlink(lockPath);
   } catch {
@@ -496,6 +831,11 @@ var CONCEPT_EXTRACTION_TOOL = {
             is_new: {
               type: "boolean",
               description: "True if this is a new concept not in existing wiki"
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "2-4 categorical tags for organizing this concept (e.g., 'machine-learning', 'optimization')"
             }
           },
           required: ["concept", "summary", "is_new"]
@@ -539,6 +879,12 @@ ${relatedPages}` : "";
     "Include a ## Sources section at the end listing the source document.",
     "Suggest [[wikilinks]] to related concepts where appropriate.",
     "Write in a neutral, informative tone. Be concise but thorough.",
+    "",
+    "Source attribution: at the end of each prose paragraph, append a citation",
+    "marker showing which source file(s) the paragraph drew from.",
+    "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.",
+    "Source filenames are visible as `--- SOURCE: filename.md ---` headers in the content below.",
     existingSection,
     relatedSection,
     "\n\n--- SOURCE MATERIAL ---\n\n",
@@ -550,8 +896,13 @@ function parseConcepts(toolOutput) {
     const parsed = JSON.parse(toolOutput);
     const concepts = parsed.concepts ?? [];
     return concepts.filter(
-      (c) => typeof c.concept === "string" && typeof c.summary === "string" && typeof c.is_new === "boolean"
-    );
+      (c) => typeof c.concept === "string" && typeof c.summary === "string" && typeof c.is_new === "boolean" && (c.tags === void 0 || Array.isArray(c.tags))
+    ).map((c) => ({
+      concept: c.concept,
+      summary: c.summary,
+      is_new: c.is_new,
+      tags: Array.isArray(c.tags) ? c.tags : void 0
+    }));
   } catch {
     return [];
   }
@@ -560,13 +911,13 @@ function parseConcepts(toolOutput) {
 // src/compiler/hasher.ts
 import { createHash } from "crypto";
 import { readFile as readFile5, readdir } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 async function hashFile(filePath) {
   const content = await readFile5(filePath, "utf-8");
   return createHash("sha256").update(content).digest("hex");
 }
 async function detectChanges(root, prevState) {
-  const sourcesPath = path6.join(root, SOURCES_DIR);
+  const sourcesPath = path7.join(root, SOURCES_DIR);
   const currentFiles = await listSourceFiles(sourcesPath);
   const changes = [];
   for (const file of currentFiles) {
@@ -586,7 +937,7 @@ async function listSourceFiles(sourcesPath) {
   }
 }
 async function classifyFile(root, file, prevState) {
-  const filePath = path6.join(root, SOURCES_DIR, file);
+  const filePath = path7.join(root, SOURCES_DIR, file);
   const hash = await hashFile(filePath);
   const prev = prevState.sources[file];
   if (!prev) return "new";
@@ -613,28 +964,37 @@ function buildConceptToSourcesMap(sources) {
   }
   return conceptMap;
 }
-function findAffectedSources(state, directChanges) {
-  const changedFiles = new Set(
-    directChanges.filter((c) => c.status === "new" || c.status === "changed").map((c) => c.file)
-  );
-  const deletedFiles = new Set(
-    directChanges.filter((c) => c.status === "deleted").map((c) => c.file)
+function filesByStatus(changes, ...statuses) {
+  const statusSet = new Set(statuses);
+  return new Set(
+    changes.filter((c) => statusSet.has(c.status)).map((c) => c.file)
   );
+}
+function collectSharedContributors(sourceFile, state, conceptMap, excludeSets, out) {
+  const sourceEntry = state.sources[sourceFile];
+  if (!sourceEntry) return;
+  for (const slug of sourceEntry.concepts) {
+    const contributors = conceptMap.get(slug);
+    if (!contributors || contributors.length < 2) continue;
+    for (const contributor of contributors) {
+      const isExcluded = excludeSets.some((s) => s.has(contributor));
+      if (!isExcluded) out.add(contributor);
+    }
+  }
+}
+function findAffectedSources(state, directChanges) {
+  const changedFiles = filesByStatus(directChanges, "new", "changed");
+  const deletedFiles = filesByStatus(directChanges, "deleted");
   const conceptMap = buildConceptToSourcesMap(state.sources);
   const affected = /* @__PURE__ */ new Set();
   for (const changedFile of changedFiles) {
-    const sourceEntry = state.sources[changedFile];
-    if (!sourceEntry) continue;
-    for (const slug of sourceEntry.concepts) {
-      const contributors = conceptMap.get(slug);
-      if (!contributors || contributors.length < 2) continue;
-      for (const contributor of contributors) {
-        const skip = changedFiles.has(contributor) || deletedFiles.has(contributor) || affected.has(contributor);
-        if (!skip) {
-          affected.add(contributor);
-        }
-      }
-    }
+    collectSharedContributors(
+      changedFile,
+      state,
+      conceptMap,
+      [changedFiles, deletedFiles, affected],
+      affected
+    );
   }
   return Array.from(affected);
 }
@@ -676,36 +1036,36 @@ async function persistFrozenSlugs(root, frozenSlugs, successfulExtractions) {
   const stateToSave = { ...currentState, frozenSlugs: Array.from(remaining) };
   await writeState(root, stateToSave);
 }
-function findLateAffectedSources(extractions, state, allChanges) {
-  const compilingFiles = new Set(
-    allChanges.filter((c) => c.status === "new" || c.status === "changed").map((c) => c.file)
-  );
-  const deletedFiles = new Set(
-    allChanges.filter((c) => c.status === "deleted").map((c) => c.file)
-  );
-  const conceptMap = buildConceptToSourcesMap(state.sources);
+function collectFreshSlugs(extractions, state) {
   const freshSlugs = /* @__PURE__ */ new Set();
   for (const result of extractions) {
     const oldConcepts = new Set(state.sources[result.sourceFile]?.concepts ?? []);
     for (const c of result.concepts) {
       const slug = slugify(c.concept);
-      if (!oldConcepts.has(slug)) {
-        freshSlugs.add(slug);
-      }
+      if (!oldConcepts.has(slug)) freshSlugs.add(slug);
     }
   }
+  return freshSlugs;
+}
+function findSlugOwners(slugs, conceptMap, excludeSets) {
   const affected = /* @__PURE__ */ new Set();
-  for (const slug of freshSlugs) {
+  for (const slug of slugs) {
     const owners = conceptMap.get(slug);
     if (!owners) continue;
     for (const owner of owners) {
-      if (!compilingFiles.has(owner) && !deletedFiles.has(owner)) {
-        affected.add(owner);
-      }
+      const isExcluded = excludeSets.some((s) => s.has(owner));
+      if (!isExcluded) affected.add(owner);
     }
   }
   return Array.from(affected);
 }
+function findLateAffectedSources(extractions, state, allChanges) {
+  const compilingFiles = filesByStatus(allChanges, "new", "changed");
+  const deletedFiles = filesByStatus(allChanges, "deleted");
+  const conceptMap = buildConceptToSourcesMap(state.sources);
+  const freshSlugs = collectFreshSlugs(extractions, state);
+  return findSlugOwners(freshSlugs, conceptMap, [compilingFiles, deletedFiles]);
+}
 function findSharedConcepts(sourceFile, state) {
   const shared = /* @__PURE__ */ new Set();
   const sourceEntry = state.sources[sourceFile];
@@ -735,7 +1095,7 @@ async function freezeFailedExtractions(root, results, frozenSlugs) {
 }
 
 // src/compiler/orphan.ts
-import path7 from "path";
+import path8 from "path";
 async function markOrphaned(root, sourceFile, state) {
   const sourceEntry = state.sources[sourceFile];
   if (!sourceEntry) return;
@@ -761,7 +1121,7 @@ async function orphanUnownedFrozenPages(root, frozenSlugs) {
   }
 }
 async function orphanPage(root, slug, reason) {
-  const pagePath = path7.join(root, CONCEPTS_DIR, `${slug}.md`);
+  const pagePath = path8.join(root, CONCEPTS_DIR, `${slug}.md`);
   const content = await safeReadFile(pagePath);
   if (!content) return;
   const { meta } = parseFrontmatter(content);
@@ -773,16 +1133,16 @@ async function orphanPage(root, slug, reason) {
 
 // src/compiler/resolver.ts
 import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 import { existsSync as existsSync2 } from "fs";
 async function buildTitleIndex(root) {
-  const conceptsDir = path8.join(root, CONCEPTS_DIR);
+  const conceptsDir = path9.join(root, CONCEPTS_DIR);
   if (!existsSync2(conceptsDir)) return [];
   const files = await readdir2(conceptsDir);
   const pages = [];
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = path8.join(conceptsDir, file);
+    const filePath = path9.join(conceptsDir, file);
     const content = await readFile6(filePath, "utf-8");
     const { meta } = parseFrontmatter(content);
     if (meta.title && typeof meta.title === "string" && !meta.orphaned) {
@@ -802,25 +1162,41 @@ function isInsideWikilink(text, position) {
   const closeBefore = text.indexOf("]]", before);
   return closeBefore >= position;
 }
+function isInsideCitation(text, position) {
+  const before = text.lastIndexOf("^[", position);
+  const after = text.indexOf("]", position);
+  if (before === -1 || after === -1) return false;
+  const closeBefore = text.indexOf("]", before);
+  return closeBefore >= position;
+}
 function isWordBoundary(text, start, end) {
   const before = start === 0 || /[\s,.:;!?()\[\]{}/"']/.test(text[start - 1]);
   const after = end >= text.length || /[\s,.:;!?()\[\]{}/"']/.test(text[end]);
   return before && after;
 }
+function findTitleMatches(text, title) {
+  const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(escaped, "gi");
+  const matches = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    matches.push({ start: match.index, end: match.index + match[0].length });
+  }
+  return matches;
+}
+function isLinkablePosition(text, start, end) {
+  if (isInsideWikilink(text, start)) return false;
+  if (isInsideCitation(text, start)) return false;
+  return isWordBoundary(text, start, end);
+}
 function addWikilinks(body, titles, selfTitle) {
   let result = body;
+  const selfLower = selfTitle.toLowerCase();
   for (const page of titles) {
-    if (page.title.toLowerCase() === selfTitle.toLowerCase()) continue;
-    const escaped = page.title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(escaped, "gi");
-    let match;
-    const matches = [];
-    while ((match = regex.exec(result)) !== null) {
-      matches.push({ start: match.index, end: match.index + match[0].length });
-    }
+    if (page.title.toLowerCase() === selfLower) continue;
+    const matches = findTitleMatches(result, page.title);
     for (const m of matches.reverse()) {
-      if (isInsideWikilink(result, m.start)) continue;
-      if (!isWordBoundary(result, m.start, m.end)) continue;
+      if (!isLinkablePosition(result, m.start, m.end)) continue;
       result = result.slice(0, m.start) + `[[${page.title}]]` + result.slice(m.end);
     }
   }
@@ -876,41 +1252,43 @@ async function linkPage(page, titleIndex) {
 
 // src/compiler/indexgen.ts
 import { readdir as readdir3 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 async function generateIndex(root) {
   status("*", info("Generating index..."));
-  const conceptsPath = path9.join(root, CONCEPTS_DIR);
-  const queriesPath = path9.join(root, QUERIES_DIR);
+  const conceptsPath = path10.join(root, CONCEPTS_DIR);
+  const queriesPath = path10.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 = path9.join(root, INDEX_FILE);
+  const indexPath = path10.join(root, INDEX_FILE);
   await atomicWrite(indexPath, indexContent);
   const total = concepts.length + queries.length;
   status("+", success(`Index updated with ${total} pages.`));
 }
-async function collectPageSummaries(conceptsPath) {
+async function scanWikiPages(dirPath) {
   let files;
   try {
-    files = await readdir3(conceptsPath);
+    files = await readdir3(dirPath);
   } catch {
     return [];
   }
-  const pages = [];
+  const scanned = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path9.join(conceptsPath, file));
+    const content = await safeReadFile(path10.join(dirPath, file));
     const { meta } = parseFrontmatter(content);
-    if (meta.title && typeof meta.title === "string" && !meta.orphaned) {
-      pages.push({
-        title: meta.title,
-        slug: file.replace(/\.md$/, ""),
-        summary: typeof meta.summary === "string" ? meta.summary : ""
-      });
-    }
+    scanned.push({ slug: file.replace(/\.md$/, ""), meta });
   }
-  return pages;
+  return scanned;
+}
+async function collectPageSummaries(conceptsPath) {
+  const scanned = await scanWikiPages(conceptsPath);
+  return scanned.filter(({ meta }) => meta.title && typeof meta.title === "string" && !meta.orphaned).map(({ slug, meta }) => ({
+    title: meta.title,
+    slug,
+    summary: typeof meta.summary === "string" ? meta.summary : ""
+  }));
 }
 function stripWikilinks(text) {
   return text.replace(/\[\[([^\]]+)\]\]/g, "$1");
@@ -933,84 +1311,378 @@ function buildIndexContent(concepts, queries) {
   return lines.join("\n");
 }
 
+// src/compiler/obsidian.ts
+import { readdir as readdir4 } from "fs/promises";
+import path11 from "path";
+var ABBREVIATION_MIN_WORDS = 3;
+var SWAP_CONJUNCTIONS = [" and ", " or "];
+function addObsidianMeta(frontmatter, conceptTitle, tags) {
+  frontmatter.tags = tags;
+  frontmatter.aliases = generateAliases(conceptTitle);
+}
+function generateAliases(title) {
+  const aliases = [];
+  const slug = slugify(title);
+  if (slug !== title) {
+    aliases.push(slug);
+  }
+  const swapAlias = generateSwapAlias(title);
+  if (swapAlias) {
+    aliases.push(swapAlias);
+  }
+  const abbreviation = generateAbbreviation(title);
+  if (abbreviation) {
+    aliases.push(abbreviation);
+  }
+  return aliases;
+}
+function generateSwapAlias(title) {
+  for (const conjunction of SWAP_CONJUNCTIONS) {
+    const index = title.toLowerCase().indexOf(conjunction);
+    if (index === -1) continue;
+    const before = title.slice(0, index);
+    const after = title.slice(index + conjunction.length);
+    const originalConjunction = title.slice(index, index + conjunction.length);
+    return `${after}${originalConjunction}${before}`;
+  }
+  return null;
+}
+function generateAbbreviation(title) {
+  const words = title.split(/\s+/);
+  if (words.length < ABBREVIATION_MIN_WORDS) return null;
+  const abbreviation = words.map((w) => w[0].toUpperCase()).join("");
+  if (abbreviation === title) return null;
+  return abbreviation;
+}
+async function generateMOC(root) {
+  const conceptsPath = path11.join(root, CONCEPTS_DIR);
+  const pages = await loadConceptPages(conceptsPath);
+  const tagGroups = groupPagesByTag(pages);
+  const content = buildMOCContent(tagGroups);
+  await atomicWrite(path11.join(root, MOC_FILE), content);
+}
+async function loadConceptPages(conceptsPath) {
+  let files;
+  try {
+    files = await readdir4(conceptsPath);
+  } catch {
+    return [];
+  }
+  const pages = [];
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const content = await safeReadFile(path11.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 tags = Array.isArray(meta.tags) ? meta.tags : [];
+    pages.push({ title, tags });
+  }
+  return pages;
+}
+function groupPagesByTag(pages) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    if (page.tags.length === 0) {
+      appendToGroup(groups, "Uncategorized", page.title);
+      continue;
+    }
+    for (const tag of page.tags) {
+      appendToGroup(groups, tag, page.title);
+    }
+  }
+  return groups;
+}
+function appendToGroup(groups, key, title) {
+  const existing = groups.get(key);
+  if (existing) {
+    existing.push(title);
+  } else {
+    groups.set(key, [title]);
+  }
+}
+function buildMOCContent(tagGroups) {
+  const lines = ["# Map of Content", ""];
+  const sortedTags = [...tagGroups.keys()].sort((a, b) => {
+    if (a === "Uncategorized") return 1;
+    if (b === "Uncategorized") return -1;
+    return a.localeCompare(b);
+  });
+  for (const tag of sortedTags) {
+    const titles = tagGroups.get(tag) ?? [];
+    lines.push(`## ${tag}`, "");
+    for (const title of titles.sort()) {
+      lines.push(`- [[${title}]]`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/utils/embeddings.ts
+import { readFile as readFile7, readdir as readdir5 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import path12 from "path";
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length || a.length === 0) return 0;
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  if (magA === 0 || magB === 0) return 0;
+  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+function findTopK(queryVec, store, k) {
+  const scored = store.entries.map((entry) => ({
+    entry,
+    score: cosineSimilarity(queryVec, entry.vector)
+  }));
+  scored.sort((left, right) => right.score - left.score);
+  return scored.slice(0, k).map((item) => item.entry);
+}
+async function readEmbeddingStore(root) {
+  const filePath = path12.join(root, EMBEDDINGS_FILE);
+  if (!existsSync3(filePath)) return null;
+  const raw = await readFile7(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+async function writeEmbeddingStore(root, store) {
+  const filePath = path12.join(root, EMBEDDINGS_FILE);
+  await atomicWrite(filePath, JSON.stringify(store, null, 2));
+}
+async function findRelevantPages(root, question) {
+  const store = await readEmbeddingStore(root);
+  if (!store || store.entries.length === 0) return [];
+  const queryVec = await getProvider().embed(question);
+  return findTopK(queryVec, store, EMBEDDING_TOP_K).map((entry) => ({
+    slug: entry.slug,
+    title: entry.title,
+    summary: entry.summary
+  }));
+}
+async function collectPageRecords(root) {
+  const records = [];
+  for (const dir of [CONCEPTS_DIR, QUERIES_DIR]) {
+    const absDir = path12.join(root, dir);
+    let files;
+    try {
+      files = await readdir5(absDir);
+    } catch {
+      continue;
+    }
+    for (const file of files.filter((f) => f.endsWith(".md"))) {
+      const content = await safeReadFile(path12.join(absDir, file));
+      const { meta } = parseFrontmatter(content);
+      if (meta.orphaned || typeof meta.title !== "string") continue;
+      records.push({
+        slug: file.replace(/\.md$/, ""),
+        title: meta.title,
+        summary: typeof meta.summary === "string" ? meta.summary : ""
+      });
+    }
+  }
+  return records;
+}
+function buildEmbeddingText(record) {
+  return record.summary ? `${record.title}
+
+${record.summary}` : record.title;
+}
+async function embedPages(records, slugsToEmbed) {
+  const provider = getProvider();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const fresh = [];
+  for (const record of records) {
+    if (!slugsToEmbed.has(record.slug)) continue;
+    const vector = await provider.embed(buildEmbeddingText(record));
+    fresh.push({
+      slug: record.slug,
+      title: record.title,
+      summary: record.summary,
+      vector,
+      updatedAt: now
+    });
+  }
+  return fresh;
+}
+function resolveEmbeddingModel() {
+  return EMBEDDING_MODELS[getActiveProviderName()] ?? EMBEDDING_MODELS.anthropic;
+}
+function mergeEntries(existing, fresh, liveSlugs) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const entry of existing) {
+    if (liveSlugs.has(entry.slug)) bySlug.set(entry.slug, entry);
+  }
+  for (const entry of fresh) {
+    bySlug.set(entry.slug, entry);
+  }
+  return Array.from(bySlug.values());
+}
+async function updateEmbeddings(root, changedSlugs) {
+  const records = await collectPageRecords(root);
+  const liveSlugs = new Set(records.map((r) => r.slug));
+  const toEmbed = new Set(changedSlugs.filter((slug) => liveSlugs.has(slug)));
+  const existingStore = await readEmbeddingStore(root);
+  const previousEntries = existingStore?.entries ?? [];
+  if (!existingStore) {
+    for (const record of records) toEmbed.add(record.slug);
+  }
+  if (toEmbed.size === 0 && previousEntries.every((e) => liveSlugs.has(e.slug))) {
+    return;
+  }
+  const freshEntries = await embedPages(records, toEmbed);
+  const mergedEntries = mergeEntries(previousEntries, freshEntries, liveSlugs);
+  const dimensions = mergedEntries[0]?.vector.length ?? 0;
+  const store = {
+    version: 1,
+    model: resolveEmbeddingModel(),
+    dimensions,
+    entries: mergedEntries
+  };
+  await writeEmbeddingStore(root, store);
+  status("*", dim(`Embeddings updated (${mergedEntries.length} pages).`));
+}
+
 // 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) {
+  await compileAndReport(root);
+}
+async function compileAndReport(root) {
   header("llmwiki compile");
   const locked = await acquireLock(root);
   if (!locked) {
     status("!", error("Could not acquire lock. Try again later."));
-    return;
+    return {
+      ...emptyCompileResult(),
+      errors: ["Could not acquire .llmwiki/lock \u2014 another compile is in progress."]
+    };
   }
   try {
-    await runCompilePipeline(root);
+    return await runCompilePipeline(root);
   } 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) {
+  const merged = mergeExtractions(extractions, frozenSlugs);
+  const limit = pLimit(COMPILE_CONCURRENCY);
+  const errors = [];
+  const pages = await Promise.all(
+    merged.map((entry) => limit(async () => {
+      const writeError = await generateMergedPage(root, entry);
+      if (writeError) errors.push(writeError);
+      return entry;
+    }))
+  );
+  return { pages, errors };
+}
+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) {
+  header("Compilation complete");
+  status("\u2713", success(
+    `${buckets.toCompile.length} compiled, ${buckets.unchanged.length} skipped, ${buckets.deleted.length} deleted`
+  ));
+  if (buckets.toCompile.length > 0) {
+    status("\u2192", dim('Next: llmwiki query "your question here"'));
+  }
+  const errors = [...generation.errors];
+  for (const result of extractions) {
+    if (result.concepts.length === 0) {
+      errors.push(`No concepts extracted from ${result.sourceFile}`);
+    }
+  }
+  return {
+    compiled: buckets.toCompile.length,
+    skipped: buckets.unchanged.length,
+    deleted: buckets.deleted.length,
+    concepts: generation.pages.map((entry) => entry.concept.concept),
+    pages: generation.pages.map((entry) => entry.slug),
+    errors
+  };
+}
 async function runCompilePipeline(root) {
   const state = await readState(root);
   const changes = await detectChanges(root, state);
-  const affectedFiles = findAffectedSources(state, changes);
-  for (const file of affectedFiles) {
-    status("~", info(`${file} [affected by shared concept]`));
-    changes.push({ file, status: "changed" });
-  }
-  const toCompile = changes.filter((c) => c.status === "new" || c.status === "changed");
-  const deleted = changes.filter((c) => c.status === "deleted");
-  const unchanged = changes.filter((c) => c.status === "unchanged");
-  if (toCompile.length === 0 && deleted.length === 0) {
+  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."));
-    return;
+    return { ...emptyCompileResult(), skipped: buckets.unchanged.length };
   }
   printChangesSummary(changes);
+  await markDeletedAsOrphaned(root, buckets.deleted, state);
+  const frozenSlugs = findFrozenSlugs(state, changes);
+  reportFrozenSlugs(frozenSlugs);
+  const extractions = await runExtractionPhases(root, buckets.toCompile, state, changes);
+  await freezeFailedExtractions(root, extractions, frozenSlugs);
+  const generation = await generatePagesPhase(root, extractions, frozenSlugs);
+  await persistExtractionStates(root, extractions);
+  if (frozenSlugs.size > 0) {
+    await orphanUnownedFrozenPages(root, frozenSlugs);
+  }
+  await persistFrozenSlugs(root, frozenSlugs, extractions);
+  await finalizeWiki(root, generation.pages);
+  return summarizeCompile(buckets, generation, extractions);
+}
+function augmentWithAffectedSources(changes, affected) {
+  for (const file of affected) {
+    status("~", info(`${file} [affected by shared concept]`));
+    changes.push({ file, status: "changed" });
+  }
+}
+async function markDeletedAsOrphaned(root, deleted, state) {
   for (const del of deleted) {
     await markOrphaned(root, del.file, state);
   }
-  const frozenSlugs = findFrozenSlugs(state, changes);
+}
+function reportFrozenSlugs(frozenSlugs) {
   for (const slug of frozenSlugs) {
     status("i", dim(`Frozen: ${slug} (shared with deleted source)`));
   }
+}
+async function runExtractionPhases(root, toCompile, state, allChanges) {
   const extractions = [];
   for (const change of toCompile) {
     extractions.push(await extractForSource(root, change.file));
   }
-  const lateAffected = findLateAffectedSources(extractions, state, changes);
+  const lateAffected = findLateAffectedSources(extractions, state, allChanges);
   for (const file of lateAffected) {
     status("~", info(`${file} [shares concept with new source]`));
     extractions.push(await extractForSource(root, file));
   }
-  await freezeFailedExtractions(root, extractions, frozenSlugs);
-  const merged = mergeExtractions(extractions, frozenSlugs);
-  const limit = pLimit(COMPILE_CONCURRENCY);
-  const pageResults = await Promise.all(
-    merged.map((entry) => limit(async () => {
-      await generateMergedPage(root, entry);
-      return entry;
-    }))
-  );
-  const allChangedSlugs = pageResults.map((e) => e.slug);
-  const allNewSlugs = pageResults.filter((e) => e.concept.is_new).map((e) => e.slug);
-  for (const result of extractions) {
-    if (result.concepts.length === 0) continue;
-    await persistSourceState(root, result.sourcePath, result.sourceFile, result.concepts);
-  }
-  if (frozenSlugs.size > 0) {
-    await orphanUnownedFrozenPages(root, frozenSlugs);
-  }
-  await persistFrozenSlugs(root, frozenSlugs, extractions);
+  return extractions;
+}
+async function finalizeWiki(root, pages) {
+  const allChangedSlugs = pages.map((entry) => entry.slug);
+  const allNewSlugs = pages.filter((entry) => entry.concept.is_new).map((entry) => entry.slug);
   if (allChangedSlugs.length > 0) {
     status("\u{1F517}", info("Resolving interlinks..."));
     await resolveLinks(root, allChangedSlugs, allNewSlugs);
   }
   await generateIndex(root);
-  header("Compilation complete");
-  status("\u2713", success(
-    `${toCompile.length} compiled, ${unchanged.length} skipped, ${deleted.length} deleted`
-  ));
-  if (toCompile.length > 0) {
-    status("\u2192", dim('Next: llmwiki query "your question here"'));
-  }
+  await generateMOC(root);
+  await safelyUpdateEmbeddings(root, allChangedSlugs);
 }
 function printChangesSummary(changes) {
   const iconMap = {
@@ -1033,9 +1705,9 @@ function printChangesSummary(changes) {
 }
 async function extractForSource(root, sourceFile) {
   status("*", info(`Extracting: ${sourceFile}`));
-  const sourcePath = path10.join(root, SOURCES_DIR, sourceFile);
-  const sourceContent = await readFile7(sourcePath, "utf-8");
-  const existingIndex = await safeReadFile(path10.join(root, INDEX_FILE));
+  const sourcePath = path13.join(root, SOURCES_DIR, sourceFile);
+  const sourceContent = await readFile8(sourcePath, "utf-8");
+  const existingIndex = await safeReadFile(path13.join(root, INDEX_FILE));
   const concepts = await extractConcepts(sourceContent, existingIndex);
   if (concepts.length > 0) {
     const names = concepts.map((c) => c.concept).join(", ");
@@ -1073,7 +1745,7 @@ ${result.sourceContent}`
   return Array.from(bySlug.values());
 }
 async function generateMergedPage(root, entry) {
-  const pagePath = path10.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
+  const pagePath = path13.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
   const existingPage = await safeReadFile(pagePath);
   const relatedPages = await loadRelatedPages(root, entry.slug);
   const system = buildPagePrompt(
@@ -1091,18 +1763,20 @@ async function generateMergedPage(root, entry) {
   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 frontmatter = buildFrontmatter({
+  const frontmatterFields = {
     title: entry.concept.concept,
     summary: entry.concept.summary,
     sources: entry.sourceFiles,
     createdAt,
     updatedAt: now
-  });
+  };
+  addObsidianMeta(frontmatterFields, entry.concept.concept, entry.concept.tags ?? []);
+  const frontmatter = buildFrontmatter(frontmatterFields);
   const fullPage = `${frontmatter}
 
 ${pageBody}
 `;
-  await writePageIfValid(pagePath, fullPage, entry.concept.concept);
+  return await writePageIfValid(pagePath, fullPage, entry.concept.concept);
 }
 async function extractConcepts(sourceContent, existingIndex) {
   const system = buildExtractionPrompt(sourceContent, existingIndex);
@@ -1114,17 +1788,17 @@ async function extractConcepts(sourceContent, existingIndex) {
   return parseConcepts(rawOutput);
 }
 async function loadRelatedPages(root, excludeSlug) {
-  const conceptsPath = path10.join(root, CONCEPTS_DIR);
+  const conceptsPath = path13.join(root, CONCEPTS_DIR);
   let files;
   try {
-    files = await readdir4(conceptsPath);
+    files = await readdir6(conceptsPath);
   } catch {
     return "";
   }
   const related = files.filter((f) => f.endsWith(".md") && f !== `${excludeSlug}.md`).slice(0, 5);
   const contents = [];
   for (const f of related) {
-    const content = await safeReadFile(path10.join(conceptsPath, f));
+    const content = await safeReadFile(path13.join(conceptsPath, f));
     if (!content) continue;
     const { meta } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -1135,9 +1809,18 @@ async function loadRelatedPages(root, excludeSlug) {
 async function writePageIfValid(pagePath, content, conceptTitle) {
   if (!validateWikiPage(content)) {
     status("!", warn(`Invalid page for "${conceptTitle}" \u2014 skipped.`));
-    return;
+    return `Invalid page for "${conceptTitle}" \u2014 failed validation`;
   }
   await atomicWrite(pagePath, content);
+  return null;
+}
+async function safelyUpdateEmbeddings(root, changedSlugs) {
+  try {
+    await updateEmbeddings(root, changedSlugs);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    status("!", warn(`Skipped embeddings update: ${message}`));
+  }
 }
 async function persistSourceState(root, sourcePath, sourceFile, concepts) {
   const hash = await hashFile(sourcePath);
@@ -1151,7 +1834,7 @@ async function persistSourceState(root, sourcePath, sourceFile, concepts) {
 
 // src/commands/compile.ts
 async function compileCommand() {
-  if (!existsSync3(SOURCES_DIR)) {
+  if (!existsSync4(SOURCES_DIR)) {
     status(
       "!",
       warn("No sources found. Run `llmwiki ingest <url>` first.")
@@ -1162,8 +1845,8 @@ async function compileCommand() {
 }
 
 // src/commands/query.ts
-import { existsSync as existsSync4 } from "fs";
-import path11 from "path";
+import { existsSync as existsSync5 } from "fs";
+import path14 from "path";
 var PAGE_DIRS = [CONCEPTS_DIR, QUERIES_DIR];
 var PAGE_SELECTION_TOOL = {
   name: "select_pages",
@@ -1208,12 +1891,35 @@ ${indexContent}`;
     return { pages: [], reasoning: "Failed to parse page selection response" };
   }
 }
+function buildFilteredIndex(candidates) {
+  return candidates.map((entry) => `- **${entry.slug}**: ${entry.title} \u2014 ${entry.summary}`).join("\n");
+}
+async function selectRelevantPages(root, question) {
+  const candidates = await tryFindRelevantPages(root, question);
+  if (candidates.length > 0) {
+    const filteredIndex = buildFilteredIndex(candidates);
+    const { pages: rawPages2, reasoning: reasoning2 } = await selectPages(question, filteredIndex);
+    return { pages: rawPages2, rawPages: rawPages2, reasoning: reasoning2 };
+  }
+  const indexContent = await safeReadFile(path14.join(root, INDEX_FILE));
+  const { pages: rawPages, reasoning } = await selectPages(question, indexContent);
+  return { pages: rawPages.map((p) => slugify(p)), rawPages, reasoning };
+}
+async function tryFindRelevantPages(root, question) {
+  try {
+    return await findRelevantPages(root, question);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    status("!", dim(`Semantic pre-filter unavailable (${message}); using full index.`));
+    return [];
+  }
+}
 async function loadSelectedPages(root, slugs) {
   const sections = [];
   for (const slug of slugs) {
     let content = "";
     for (const dir of PAGE_DIRS) {
-      const candidate = await safeReadFile(path11.join(root, dir, `${slug}.md`));
+      const candidate = await safeReadFile(path14.join(root, dir, `${slug}.md`));
       if (!candidate) continue;
       const { meta } = parseFrontmatter(candidate);
       if (meta.orphaned) continue;
@@ -1229,20 +1935,18 @@ ${content}`);
   }
   return sections.join("\n\n");
 }
-async function streamAnswer(question, pagesContent) {
-  const systemPrompt = "You are a knowledge assistant. Answer the question using ONLY the wiki content provided. Cite specific pages using [[Page Title]] wikilinks. If the wiki doesn't contain enough information, say so.";
+var ANSWER_SYSTEM_PROMPT = "You are a knowledge assistant. Answer the question using ONLY the wiki content provided. Cite specific pages using [[Page Title]] wikilinks. If the wiki doesn't contain enough information, say so.";
+async function callAnswerLLM(question, pagesContent, onToken) {
   const userMessage = `Question: ${question}
 
 Relevant wiki pages:
 ${pagesContent}`;
-  const answer = await callClaude({
-    system: systemPrompt,
+  return callClaude({
+    system: ANSWER_SYSTEM_PROMPT,
     messages: [{ role: "user", content: userMessage }],
-    stream: true,
-    onToken: (text) => process.stdout.write(text)
+    stream: Boolean(onToken),
+    onToken
   });
-  process.stdout.write("\n");
-  return answer;
 }
 function summarizeAnswer(answer) {
   const firstLine = answer.trim().split(/\n/)[0] ?? "";
@@ -1251,7 +1955,7 @@ function summarizeAnswer(answer) {
 }
 async function saveQueryPage(root, question, answer) {
   const slug = slugify(question);
-  const filePath = path11.join(root, QUERIES_DIR, `${slug}.md`);
+  const filePath = path14.join(root, QUERIES_DIR, `${slug}.md`);
   const frontmatter = buildFrontmatter({
     title: question,
     summary: summarizeAnswer(answer),
@@ -1268,27 +1972,52 @@ ${answer}
     success(`Saved query \u2192 ${source(filePath)}`)
   );
   await generateIndex(root);
+  try {
+    await updateEmbeddings(root, [slug]);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    status("!", warn(`Skipped embeddings update: ${message}`));
+  }
+  return slug;
+}
+async function generateAnswer(root, question, options = {}) {
+  if (!existsSync5(path14.join(root, INDEX_FILE))) {
+    throw new Error("Wiki index not found. Run `llmwiki compile` first.");
+  }
+  const { pages, reasoning } = await selectRelevantPages(root, question);
+  options.onPageSelection?.(pages, reasoning);
+  const pagesContent = await loadSelectedPages(root, pages);
+  if (!pagesContent) {
+    return { answer: "", selectedPages: pages, reasoning };
+  }
+  const answer = await callAnswerLLM(question, pagesContent, options.onToken);
+  let saved;
+  if (options.save) {
+    saved = await saveQueryPage(root, question, answer);
+  }
+  return { answer, selectedPages: pages, reasoning, saved };
 }
 async function queryCommand(root, question, options) {
-  if (!existsSync4(path11.join(root, INDEX_FILE))) {
+  if (!existsSync5(path14.join(root, INDEX_FILE))) {
     status("!", error("Wiki index not found. Run `llmwiki compile` first."));
     return;
   }
   header("Selecting relevant pages");
-  const indexContent = await safeReadFile(path11.join(root, INDEX_FILE));
-  const { pages: rawPages, reasoning } = await selectPages(question, indexContent);
-  const pages = rawPages.map((p) => slugify(p));
-  status("i", dim(`Reasoning: ${reasoning}`));
-  status("*", info(`Selected ${pages.length} page(s): ${rawPages.join(", ")}`));
-  header("Generating answer");
-  const pagesContent = await loadSelectedPages(root, pages);
-  if (!pagesContent) {
+  const result = await generateAnswer(root, question, {
+    save: options.save,
+    onToken: (text) => process.stdout.write(text),
+    onPageSelection: (pages, reasoning) => {
+      status("i", dim(`Reasoning: ${reasoning}`));
+      status("*", info(`Selected ${pages.length} page(s): ${pages.join(", ")}`));
+      header("Generating answer");
+    }
+  });
+  process.stdout.write("\n");
+  if (!result.answer) {
     status("!", error("No matching pages found. Try refining your question."));
     return;
   }
-  const answer = await streamAnswer(question, pagesContent);
-  if (options.save) {
-    await saveQueryPage(root, question, answer);
+  if (result.saved) {
     status("\u2192", dim("Saved. Future queries will use this answer as context."));
   } else {
     status("\u2192", dim("Tip: use --save to add this answer to your wiki"));
@@ -1297,12 +2026,12 @@ async function queryCommand(root, question, options) {
 
 // src/commands/watch.ts
 import { watch as chokidarWatch } from "chokidar";
-import { existsSync as existsSync5 } from "fs";
-import path12 from "path";
+import { existsSync as existsSync6 } from "fs";
+import path15 from "path";
 var DEBOUNCE_MS = 500;
 async function watchCommand() {
-  const sourcesPath = path12.resolve(SOURCES_DIR);
-  if (!existsSync5(sourcesPath)) {
+  const sourcesPath = path15.resolve(SOURCES_DIR);
+  if (!existsSync6(sourcesPath)) {
     status(
       "!",
       warn("No sources/ directory found. Run `llmwiki ingest <url>` first.")
@@ -1336,7 +2065,7 @@ async function watchCommand() {
   const scheduleCompile = (eventPath, event) => {
     status(
       "~",
-      dim(`${event}: ${path12.basename(eventPath)}`)
+      dim(`${event}: ${path15.basename(eventPath)}`)
     );
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(triggerCompile, DEBOUNCE_MS);
@@ -1350,6 +2079,609 @@ async function watchCommand() {
   });
 }
 
+// src/linter/rules.ts
+import { readdir as readdir7, readFile as readFile9 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import path16 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 (!existsSync7(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 };
+    })
+  );
+  return results;
+}
+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];
+}
+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 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 checkBrokenCitations(root) {
+  const pages = await collectAllPages(root);
+  const sourcesDir = path16.join(root, SOURCES_DIR);
+  const results = [];
+  for (const page of pages) {
+    for (const { captured, line } of findMatchesInContent(page.content, CITATION_PATTERN)) {
+      const citedPath = path16.join(sourcesDir, captured);
+      if (!existsSync7(citedPath)) {
+        results.push({
+          rule: "broken-citation",
+          severity: "error",
+          file: page.filePath,
+          message: `Broken citation ^[${captured}] \u2014 source file not found`,
+          line
+        });
+      }
+    }
+  }
+  return results;
+}
+
+// src/linter/index.ts
+var ALL_RULES = [
+  checkBrokenWikilinks,
+  checkOrphanedPages,
+  checkMissingSummaries,
+  checkDuplicateConcepts,
+  checkEmptyPages,
+  checkBrokenCitations
+];
+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();
+  return {
+    errors: countBySeverity(results, "error"),
+    warnings: countBySeverity(results, "warning"),
+    info: countBySeverity(results, "info"),
+    results
+  };
+}
+
+// src/commands/lint.ts
+var SEVERITY_FORMATTERS = {
+  error,
+  warning: warn,
+  info
+};
+var SEVERITY_ICONS = {
+  error: "x",
+  warning: "!",
+  info: "i"
+};
+function printResult(result) {
+  const formatter = SEVERITY_FORMATTERS[result.severity];
+  const icon = SEVERITY_ICONS[result.severity];
+  const location = result.line ? `${result.file}:${result.line}` : result.file;
+  status(icon, `${formatter(result.severity)} ${dim(location)} ${result.message}`);
+}
+async function lintCommand() {
+  header("Linting wiki");
+  const summary = await lint(process.cwd());
+  for (const result of summary.results) {
+    printResult(result);
+  }
+  console.log();
+  const summaryLine = [
+    error(`${summary.errors} error(s)`),
+    warn(`${summary.warnings} warning(s)`),
+    info(`${summary.info} info`)
+  ].join(", ");
+  status("*", summaryLine);
+  if (summary.errors > 0) {
+    process.exit(1);
+  }
+}
+
+// src/mcp/server.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/tools.ts
+import path17 from "path";
+import { z } from "zod";
+
+// src/mcp/provider-check.ts
+var PROVIDER_KEY_VARS = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  ollama: null,
+  minimax: "MINIMAX_API_KEY"
+};
+function ensureProviderAvailable() {
+  const provider = process.env.LLMWIKI_PROVIDER ?? DEFAULT_PROVIDER;
+  if (provider === "anthropic") {
+    const auth = resolveAnthropicAuthFromEnv();
+    if (!auth.apiKey && !auth.authToken) {
+      throw new Error(
+        'Anthropic credentials are required for the "anthropic" provider. Set ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN.'
+      );
+    }
+    return;
+  }
+  const keyVar = PROVIDER_KEY_VARS[provider];
+  if (keyVar === void 0) {
+    throw new Error(
+      `Unknown provider "${provider}". Supported: ${Object.keys(PROVIDER_KEY_VARS).join(", ")}`
+    );
+  }
+  if (keyVar && !process.env[keyVar]) {
+    throw new Error(
+      `${keyVar} environment variable is required for the "${provider}" provider.`
+    );
+  }
+}
+
+// src/mcp/tools.ts
+var PAGE_DIRS2 = [CONCEPTS_DIR, QUERIES_DIR];
+function jsonResult(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    structuredContent: { result: payload }
+  };
+}
+function registerWikiTools(server, root) {
+  registerIngestTool(server, root);
+  registerCompileTool(server, root);
+  registerQueryTool(server, root);
+  registerSearchTool(server, root);
+  registerReadTool(server, root);
+  registerLintTool(server, root);
+  registerStatusTool(server, root);
+}
+function registerIngestTool(server, root) {
+  server.registerTool(
+    "ingest_source",
+    {
+      title: "Ingest Source",
+      description: "Fetch a URL or copy a local file into sources/. Returns the saved filename, character count, and whether content was truncated to fit the size limit.",
+      inputSchema: {
+        source: z.string().describe("URL (http/https) or absolute path to a .md/.txt file")
+      }
+    },
+    async ({ source: source2 }) => {
+      const previousCwd = process.cwd();
+      try {
+        process.chdir(root);
+        const result = await ingestSource(source2);
+        return jsonResult(result);
+      } finally {
+        process.chdir(previousCwd);
+      }
+    }
+  );
+}
+function registerCompileTool(server, root) {
+  server.registerTool(
+    "compile_wiki",
+    {
+      title: "Compile Wiki",
+      description: "Run the incremental compile pipeline: extract concepts from new/changed sources, generate wiki pages, resolve interlinks, and rebuild the index. Requires an LLM provider with credentials.",
+      inputSchema: {}
+    },
+    async () => {
+      ensureProviderAvailable();
+      const result = await compileAndReport(root);
+      return jsonResult(result);
+    }
+  );
+}
+function registerQueryTool(server, root) {
+  server.registerTool(
+    "query_wiki",
+    {
+      title: "Query Wiki",
+      description: "Ask a natural-language question. Selects relevant pages with the LLM, loads them, and returns a grounded answer with citations. Set save=true to persist the answer as a wiki page. Requires an LLM provider.",
+      inputSchema: {
+        question: z.string().describe("The natural-language question to answer."),
+        save: z.boolean().optional().describe("Persist the answer as a wiki/queries/ page when true.")
+      }
+    },
+    async ({ question, save }) => {
+      ensureProviderAvailable();
+      const result = await generateAnswer(root, question, { save });
+      return jsonResult(result);
+    }
+  );
+}
+function registerSearchTool(server, root) {
+  server.registerTool(
+    "search_pages",
+    {
+      title: "Search Pages",
+      description: "Select pages relevant to a question and return their full content. Uses semantic embeddings when available, falling back to LLM-based selection over the wiki index. Requires an LLM provider.",
+      inputSchema: {
+        question: z.string().describe("The query used to rank pages.")
+      }
+    },
+    async ({ question }) => {
+      ensureProviderAvailable();
+      const slugs = await pickSearchSlugs(root, question);
+      const records = await loadPageRecords(root, slugs);
+      return jsonResult({ pages: records });
+    }
+  );
+}
+async function pickSearchSlugs(root, question) {
+  try {
+    const candidates = await findRelevantPages(root, question);
+    if (candidates.length > 0) return candidates.map((c) => c.slug);
+  } catch {
+  }
+  const indexContent = await safeReadFile(path17.join(root, INDEX_FILE));
+  const { pages } = await selectPages(question, indexContent);
+  return pages;
+}
+function registerReadTool(server, root) {
+  server.registerTool(
+    "read_page",
+    {
+      title: "Read Page",
+      description: "Read a single wiki page by slug. Searches concepts/ first, then queries/. Returns the parsed frontmatter and body. No LLM call required.",
+      inputSchema: {
+        slug: z.string().describe("Page slug, without .md extension.")
+      }
+    },
+    async ({ slug }) => {
+      const page = await readPage(root, slug);
+      if (!page) {
+        throw new Error(`Page not found: ${slug}`);
+      }
+      return jsonResult(page);
+    }
+  );
+}
+function registerLintTool(server, root) {
+  server.registerTool(
+    "lint_wiki",
+    {
+      title: "Lint Wiki",
+      description: "Run rule-based quality checks (broken wikilinks, orphans, duplicates, empty pages, broken citations). Returns structured diagnostics. No LLM call.",
+      inputSchema: {}
+    },
+    async () => {
+      const summary = await lint(root);
+      return jsonResult(summary);
+    }
+  );
+}
+function registerStatusTool(server, root) {
+  server.registerTool(
+    "wiki_status",
+    {
+      title: "Wiki Status",
+      description: "Summarize the wiki: page count, source count, last compile time, orphaned pages, and pending source changes. Read-only \u2014 never modifies the workspace.",
+      inputSchema: {}
+    },
+    async () => jsonResult(await collectStatus(root))
+  );
+}
+async function collectStatus(root) {
+  const concepts = await collectPageSummaries(path17.join(root, CONCEPTS_DIR));
+  const queries = await collectPageSummaries(path17.join(root, QUERIES_DIR));
+  const state = await readState(root);
+  const changes = await detectChanges(root, state);
+  const orphans = await findOrphanedSlugs(root);
+  const compileTimes = Object.values(state.sources).map((s) => s.compiledAt);
+  const lastCompile = compileTimes.length > 0 ? compileTimes.sort().slice(-1)[0] : null;
+  return {
+    pages: { concepts: concepts.length, queries: queries.length, total: concepts.length + queries.length },
+    sources: Object.keys(state.sources).length,
+    lastCompiledAt: lastCompile,
+    orphanedPages: orphans,
+    pendingChanges: changes.filter((c) => c.status !== "unchanged").map((c) => ({ file: c.file, status: c.status }))
+  };
+}
+async function findOrphanedSlugs(root) {
+  const scanned = await scanWikiPages(path17.join(root, CONCEPTS_DIR));
+  return scanned.filter(({ meta }) => meta.orphaned).map(({ slug }) => slug);
+}
+async function loadPageRecords(root, slugs) {
+  const records = [];
+  for (const slug of slugs) {
+    const page = await readPage(root, slug);
+    if (page) records.push(page);
+  }
+  return records;
+}
+async function readPage(root, slug) {
+  for (const dir of PAGE_DIRS2) {
+    const content = await safeReadFile(path17.join(root, dir, `${slug}.md`));
+    if (!content) continue;
+    const { meta, body } = parseFrontmatter(content);
+    if (meta.orphaned) continue;
+    return {
+      slug,
+      title: typeof meta.title === "string" ? meta.title : slug,
+      summary: typeof meta.summary === "string" ? meta.summary : "",
+      body: body.trim()
+    };
+  }
+  return null;
+}
+
+// src/mcp/resources.ts
+import path18 from "path";
+import { readdir as readdir8 } from "fs/promises";
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function jsonContent(uri, payload) {
+  return {
+    uri: uri.href,
+    mimeType: "application/json",
+    text: JSON.stringify(payload, null, 2)
+  };
+}
+function markdownContent(uri, text) {
+  return {
+    uri: uri.href,
+    mimeType: "text/markdown",
+    text
+  };
+}
+function registerWikiResources(server, root) {
+  registerIndexResource(server, root);
+  registerSourcesResource(server, root);
+  registerStateResource(server, root);
+  registerConceptResource(server, root);
+  registerQueryResource(server, root);
+}
+function registerIndexResource(server, root) {
+  server.registerResource(
+    "wiki-index",
+    "llmwiki://index",
+    {
+      title: "Wiki Index",
+      description: "Full content of wiki/index.md (auto-generated table of contents).",
+      mimeType: "text/markdown"
+    },
+    async (uri) => {
+      const content = await safeReadFile(path18.join(root, INDEX_FILE));
+      return { contents: [markdownContent(uri, content)] };
+    }
+  );
+}
+function registerSourcesResource(server, root) {
+  server.registerResource(
+    "wiki-sources",
+    "llmwiki://sources",
+    {
+      title: "Wiki Sources",
+      description: "List of ingested source files with frontmatter metadata.",
+      mimeType: "application/json"
+    },
+    async (uri) => ({
+      contents: [jsonContent(uri, await listSources(root))]
+    })
+  );
+}
+function registerStateResource(server, root) {
+  server.registerResource(
+    "wiki-state",
+    "llmwiki://state",
+    {
+      title: "Compilation State",
+      description: "Per-source hashes, concepts, and last compile times from .llmwiki/state.json.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const state = await readState(root);
+      return { contents: [jsonContent(uri, state)] };
+    }
+  );
+}
+function registerConceptResource(server, root) {
+  server.registerResource(
+    "wiki-concept",
+    new ResourceTemplate("llmwiki://concept/{slug}", {
+      list: async () => listPagesUnder(root, CONCEPTS_DIR, "concept")
+    }),
+    {
+      title: "Wiki Concept",
+      description: "A single concept page from wiki/concepts/ \u2014 frontmatter plus body.",
+      mimeType: "application/json"
+    },
+    async (uri, { slug }) => ({
+      contents: [jsonContent(uri, await loadPageWithMeta(root, CONCEPTS_DIR, String(slug)))]
+    })
+  );
+}
+function registerQueryResource(server, root) {
+  server.registerResource(
+    "wiki-query",
+    new ResourceTemplate("llmwiki://query/{slug}", {
+      list: async () => listPagesUnder(root, QUERIES_DIR, "query")
+    }),
+    {
+      title: "Wiki Query",
+      description: "A single saved query page from wiki/queries/ \u2014 frontmatter plus body.",
+      mimeType: "application/json"
+    },
+    async (uri, { slug }) => ({
+      contents: [jsonContent(uri, await loadPageWithMeta(root, QUERIES_DIR, String(slug)))]
+    })
+  );
+}
+async function listSources(root) {
+  const sourcesPath = path18.join(root, SOURCES_DIR);
+  let files;
+  try {
+    files = await readdir8(sourcesPath);
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const file of files.filter((f) => f.endsWith(".md"))) {
+    const content = await safeReadFile(path18.join(sourcesPath, file));
+    const { meta } = parseFrontmatter(content);
+    records.push({ filename: file, ...meta });
+  }
+  return records;
+}
+async function loadPageWithMeta(root, dir, slug) {
+  const filePath = path18.join(root, dir, `${slug}.md`);
+  const content = await safeReadFile(filePath);
+  if (!content) {
+    throw new Error(`Page not found: ${dir}/${slug}.md`);
+  }
+  const { meta, body } = parseFrontmatter(content);
+  return { slug, meta, body: body.trim() };
+}
+async function listPagesUnder(root, dir, scheme) {
+  const pagesPath = path18.join(root, dir);
+  let files;
+  try {
+    files = await readdir8(pagesPath);
+  } catch {
+    return { resources: [] };
+  }
+  const resources = files.filter((f) => f.endsWith(".md")).map((f) => {
+    const slug = f.replace(/\.md$/, "");
+    return { uri: `llmwiki://${scheme}/${slug}`, name: slug };
+  });
+  return { resources };
+}
+
+// src/mcp/server.ts
+async function startMCPServer(options) {
+  const { root, version: version2 } = options;
+  const server = new McpServer2({ name: "llmwiki", version: version2 }, {
+    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, and search_pages to retrieve relevant pages. read_page, lint_wiki, and wiki_status work without an API key."
+  });
+  registerWikiTools(server, root);
+  registerWikiResources(server, root);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -1364,8 +2696,8 @@ program.command("ingest <source>").description("Ingest a URL or local file into
   }
 });
 program.command("compile").description("Compile sources/ into an interlinked wiki").action(async () => {
-  requireApiKey();
   try {
+    requireProvider();
     await compileCommand();
   } catch (err) {
     console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
@@ -1373,8 +2705,8 @@ program.command("compile").description("Compile sources/ into an interlinked wik
   }
 });
 program.command("query <question>").description("Ask a question against the wiki").option("--save", "Save the answer as a wiki page").action(async (question, options) => {
-  requireApiKey();
   try {
+    requireProvider();
     await queryCommand(process.cwd(), question, options);
   } catch (err) {
     console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
@@ -1382,21 +2714,64 @@ program.command("query <question>").description("Ask a question against the wiki
   }
 });
 program.command("watch").description("Watch sources/ and auto-recompile on changes").action(async () => {
-  requireApiKey();
   try {
+    requireProvider();
     await watchCommand();
   } catch (err) {
     console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
     process.exit(1);
   }
 });
-program.parse();
-function requireApiKey() {
-  if (!process.env.ANTHROPIC_API_KEY) {
+program.command("lint").description("Run rule-based quality checks against the wiki").action(async () => {
+  try {
+    await lintCommand();
+  } 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 });
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+var PROVIDER_KEY_VARS2 = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  ollama: null,
+  minimax: "MINIMAX_API_KEY"
+};
+function requireProvider() {
+  const provider = process.env.LLMWIKI_PROVIDER ?? DEFAULT_PROVIDER;
+  if (provider === "anthropic") {
+    const auth = resolveAnthropicAuthFromEnv();
+    if (!auth.apiKey && !auth.authToken) {
+      console.error(
+        `\x1B[31mError:\x1B[0m Anthropic credentials are required for the "anthropic" provider.
+  Set one of: export ANTHROPIC_API_KEY=<your-key> OR export ANTHROPIC_AUTH_TOKEN=<your-token>`
+      );
+      process.exit(1);
+    }
+    return;
+  }
+  const keyVar = PROVIDER_KEY_VARS2[provider];
+  if (keyVar === void 0) {
     console.error(
-      "\x1B[31mError:\x1B[0m ANTHROPIC_API_KEY environment variable is required.\n  Set it with: export ANTHROPIC_API_KEY=sk-ant-...\n  Get a key at: https://console.anthropic.com/settings/keys"
+      `\x1B[31mError:\x1B[0m Unknown provider "${provider}".
+  Supported: ${Object.keys(PROVIDER_KEY_VARS2).join(", ")}`
+    );
+    process.exit(1);
+  }
+  if (keyVar && !process.env[keyVar]) {
+    console.error(
+      `\x1B[31mError:\x1B[0m ${keyVar} environment variable is required for the "${provider}" provider.
+  Set it with: export ${keyVar}=<your-key>`
     );
     process.exit(1);
   }
 }
+program.parse();
 //# sourceMappingURL=cli.js.map