llm-wiki-compiler 0.5.0 → 0.6.0

package/dist/cli.js

@@ -2,12 +2,12 @@
 
 // src/cli.ts
 import "dotenv/config";
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { Command } from "commander";
 
 // src/commands/ingest.ts
-import path7 from "path";
-import { mkdir as mkdir2, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
+import path8 from "path";
+import { readFile as readFile7 } from "fs/promises";
 
 // src/utils/markdown.ts
 import { writeFile, rename, readFile, mkdir } from "fs/promises";
@@ -22,7 +22,7 @@ var VALID_PROVENANCE_STATES = /* @__PURE__ */ new Set([
   "ambiguous"
 ]);
 function slugify(title) {
-  return title.toLowerCase().replace(/['']/g, "").replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return title.toLowerCase().replace(/['']/g, "").replace(/[^\p{L}\p{N}\s-]/gu, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function buildFrontmatter(fields) {
   const dumped = yaml.dump(fields, { lineWidth: -1, quotingType: '"' }).trimEnd();
@@ -103,16 +103,11 @@ function parseContradictedBy(raw) {
   const refs = raw.map(coerceContradictionEntry).filter((ref) => ref !== null);
   return refs.length > 0 ? refs : void 0;
 }
-function parseInferredParagraphs(raw) {
-  if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) return void 0;
-  return raw;
-}
 function parseProvenanceMetadata(meta) {
   return {
     confidence: parseConfidence(meta.confidence),
     provenanceState: parseProvenanceState(meta.provenanceState),
-    contradictedBy: parseContradictedBy(meta.contradictedBy),
-    inferredParagraphs: parseInferredParagraphs(meta.inferredParagraphs)
+    contradictedBy: parseContradictedBy(meta.contradictedBy)
   };
 }
 function validateWikiPage(content) {
@@ -123,9 +118,16 @@ function validateWikiPage(content) {
   return true;
 }
 
+// src/utils/source-writer.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+import { createHash } from "crypto";
+
 // src/utils/constants.ts
 var MAX_SOURCE_CHARS = 1e5;
 var MIN_SOURCE_CHARS = 50;
+var DEFAULT_PROMPT_BUDGET_CHARS = 2e5;
+var PROMPT_BUDGET_ENV_VAR = "LLMWIKI_PROMPT_BUDGET_CHARS";
 var QUERY_PAGE_LIMIT = 5;
 var COMPILE_CONCURRENCY = 5;
 var RETRY_COUNT = 3;
@@ -169,6 +171,42 @@ var EMBEDDING_MODELS = {
   ollama: "nomic-embed-text"
 };
 
+// src/utils/source-writer.ts
+var COLLISION_HASH_LEN = 8;
+function shortHashOfSource(source2) {
+  return createHash("sha256").update(source2).digest("hex").slice(0, COLLISION_HASH_LEN);
+}
+async function resolveCollisionFreeFilename(slug, source2) {
+  const candidate = `${slug}.md`;
+  const candidatePath2 = path2.join(SOURCES_DIR, candidate);
+  let existing;
+  try {
+    existing = await readFile2(candidatePath2, "utf-8");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") return candidate;
+    throw err;
+  }
+  const { meta } = parseFrontmatter(existing);
+  if (typeof meta.source === "string" && meta.source === source2) {
+    return candidate;
+  }
+  return `${slug}-${shortHashOfSource(source2)}.md`;
+}
+async function saveSource(title, document, source2) {
+  const slug = slugify(title);
+  if (!slug) {
+    throw new Error(
+      `Could not derive a filename from title "${title}". The title contains no letter or number characters. Rename the source file to one with at least one letter or digit.`
+    );
+  }
+  await mkdir2(SOURCES_DIR, { recursive: true });
+  const filename = await resolveCollisionFreeFilename(slug, source2);
+  const destPath = path2.join(SOURCES_DIR, filename);
+  await writeFile2(destPath, document, "utf-8");
+  return destPath;
+}
+
 // src/utils/output.ts
 var RESET = "\x1B[0m";
 var BOLD = "\x1B[1m";
@@ -244,13 +282,13 @@ async function ingestWeb(url) {
 }
 
 // src/ingest/file.ts
-import { readFile as readFile2 } from "fs/promises";
-import path3 from "path";
+import { readFile as readFile3 } from "fs/promises";
+import path4 from "path";
 
 // src/ingest/shared.ts
-import path2 from "path";
+import path3 from "path";
 function titleFromFilename(filePath) {
-  const basename = path2.basename(filePath, path2.extname(filePath));
+  const basename = path3.basename(filePath, path3.extname(filePath));
   return basename.replace(/[-_]+/g, " ").trim();
 }
 
@@ -262,20 +300,20 @@ ${text}
 \`\`\``;
 }
 async function ingestFile(filePath) {
-  const ext = path3.extname(filePath).toLowerCase();
+  const ext = path4.extname(filePath).toLowerCase();
   if (!SUPPORTED_EXTENSIONS.has(ext)) {
     throw new Error(
       `Unsupported file type "${ext}". Only .md and .txt files are supported.`
     );
   }
-  const raw = await readFile2(filePath, "utf-8");
+  const raw = await readFile3(filePath, "utf-8");
   const title = titleFromFilename(filePath);
   const content = ext === ".md" ? raw : wrapPlainText(raw);
   return { title, content };
 }
 
 // src/ingest/pdf.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 function resolveTitle(filePath, info2) {
   if (info2 && typeof info2 === "object") {
     const titleField = info2["Title"];
@@ -287,7 +325,7 @@ function resolveTitle(filePath, info2) {
 }
 async function ingestPdf(filePath) {
   const { PDFParse } = await import("pdf-parse");
-  const buffer = await readFile3(filePath);
+  const buffer = await readFile4(filePath);
   const parser = new PDFParse({ data: new Uint8Array(buffer) });
   try {
     const textResult = await parser.getText();
@@ -301,8 +339,8 @@ async function ingestPdf(filePath) {
 }
 
 // src/ingest/image.ts
-import { readFile as readFile4 } from "fs/promises";
-import path5 from "path";
+import { readFile as readFile5 } from "fs/promises";
+import path6 from "path";
 import Anthropic2 from "@anthropic-ai/sdk";
 
 // src/providers/anthropic.ts
@@ -419,7 +457,7 @@ var AnthropicProvider = class {
 // src/utils/claude-settings.ts
 import { readFileSync } from "fs";
 import { homedir } from "os";
-import path4 from "path";
+import path5 from "path";
 var CLAUDE_SETTINGS_PATH_ENV = "LLMWIKI_CLAUDE_SETTINGS_PATH";
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -430,7 +468,7 @@ function normalize(value) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function resolveClaudeSettingsPath(env) {
-  return env[CLAUDE_SETTINGS_PATH_ENV] ?? path4.join(homedir(), ".claude", "settings.json");
+  return env[CLAUDE_SETTINGS_PATH_ENV] ?? path5.join(homedir(), ".claude", "settings.json");
 }
 function readClaudeSettingsFile(settingsPath) {
   try {
@@ -563,9 +601,9 @@ async function ingestImage(filePath) {
       `Image ingest requires the Anthropic provider (vision). Current provider: "${providerName}". Set LLMWIKI_PROVIDER=anthropic and ANTHROPIC_API_KEY to use image ingest.`
     );
   }
-  const ext = path5.extname(filePath).toLowerCase();
+  const ext = path6.extname(filePath).toLowerCase();
   const mimeType = mimeTypeForExtension(ext);
-  const imageBuffer = await readFile4(filePath);
+  const imageBuffer = await readFile5(filePath);
   const imageData = imageBuffer.toString("base64");
   const client = buildClient();
   const model = resolveAnthropicModelFromEnv() ?? PROVIDER_MODELS.anthropic;
@@ -575,10 +613,9 @@ async function ingestImage(filePath) {
 }
 
 // src/ingest/transcript.ts
-import { readFile as readFile5 } from "fs/promises";
-import path6 from "path";
-import { YoutubeTranscript as YoutubeTranscriptUntyped } from "youtube-transcript/dist/youtube-transcript.esm.js";
-var YoutubeTranscript = YoutubeTranscriptUntyped;
+import { readFile as readFile6 } from "fs/promises";
+import path7 from "path";
+import { YoutubeTranscript } from "youtube-transcript";
 var YOUTUBE_URL_PATTERN = /^https?:\/\/(www\.)?(youtube\.com\/watch|youtu\.be\/)/;
 var SRT_SEQUENCE_PATTERN = /^\d+$/;
 var TIMESTAMP_PATTERN = /\d{2}:\d{2}[:.]\d{2}/;
@@ -662,8 +699,8 @@ async function ingestTranscript(source2) {
   if (isYoutubeUrl(source2)) {
     return fetchYoutubeTranscript(source2);
   }
-  const ext = path6.extname(source2).toLowerCase();
-  const raw = await readFile5(source2, "utf-8");
+  const ext = path7.extname(source2).toLowerCase();
+  const raw = await readFile6(source2, "utf-8");
   if (ext === ".vtt") return parseVtt(raw, source2);
   if (ext === ".srt") return parseSrt(raw, source2);
   if (ext === ".txt") return parsePlainTranscript(raw, source2);
@@ -702,7 +739,7 @@ function hasSpeakerDialoguePattern(sample) {
   return hasEnoughSpeakers && hasRepeatedSpeaker;
 }
 async function looksLikeTxtTranscript(filePath) {
-  const raw = await readFile6(filePath, "utf-8");
+  const raw = await readFile7(filePath, "utf-8");
   const sample = raw.slice(0, TXT_SNIFF_BYTES);
   if (hasSpeakerDialoguePattern(sample)) return true;
   const timestampMatches = sample.match(new RegExp(TIMESTAMP_PATTERN2.source, "gm"));
@@ -742,7 +779,7 @@ function enforceMinContent(content) {
 }
 async function detectSourceType(source2) {
   if (!isUrl(source2)) {
-    const ext = path7.extname(source2).toLowerCase();
+    const ext = path8.extname(source2).toLowerCase();
     if (ext === ".pdf") return "pdf";
     if (IMAGE_EXTENSIONS.has(ext)) return "image";
     if (TRANSCRIPT_EXTENSIONS.has(ext)) return "transcript";
@@ -788,13 +825,6 @@ async function fetchContent(source2, sourceType) {
       return ingestFile(source2);
   }
 }
-async function saveSource(title, document) {
-  const filename = `${slugify(title)}.md`;
-  const destPath = path7.join(SOURCES_DIR, filename);
-  await mkdir2(SOURCES_DIR, { recursive: true });
-  await writeFile2(destPath, document, "utf-8");
-  return destPath;
-}
 async function ingestSource(source2) {
   const sourceType = await detectSourceType(source2);
   status("*", info(`Ingesting [${sourceType}]: ${source2}`));
@@ -802,9 +832,9 @@ async function ingestSource(source2) {
   const result = enforceCharLimit(content);
   enforceMinContent(result.content);
   const document = buildDocument(title, source2, result, sourceType);
-  const savedPath = await saveSource(title, document);
+  const savedPath = await saveSource(title, document, source2);
   return {
-    filename: path7.basename(savedPath),
+    filename: path8.basename(savedPath),
     charCount: result.content.length,
     truncated: result.truncated,
     source: source2,
@@ -813,7 +843,7 @@ async function ingestSource(source2) {
 }
 async function ingest(source2) {
   const result = await ingestSource(source2);
-  const savedPath = path7.join(SOURCES_DIR, result.filename);
+  const savedPath = path8.join(SOURCES_DIR, result.filename);
   status(
     "+",
     success(`Saved ${bold(result.filename)} \u2192 ${source(savedPath)}`)
@@ -821,27 +851,390 @@ async function ingest(source2) {
   status("\u2192", dim("Next: llmwiki compile"));
 }
 
+// src/commands/ingest-session.ts
+import path12 from "path";
+import { readdir, stat } from "fs/promises";
+
+// src/adapters/claude.ts
+import { readFile as readFile8 } from "fs/promises";
+import path9 from "path";
+
+// src/adapters/utils.ts
+var MAX_TITLE_CHARS = 80;
+function truncateTitle(text) {
+  const trimmed = text.trim();
+  return trimmed.length > MAX_TITLE_CHARS ? trimmed.slice(0, MAX_TITLE_CHARS).trimEnd() + "\u2026" : trimmed;
+}
+function resolveSessionTitle(rawTitle, firstUserContent, defaultTitle) {
+  if (rawTitle && rawTitle.trim().length > 0) return truncateTitle(rawTitle);
+  if (firstUserContent) {
+    const firstLine = firstUserContent.split("\n")[0];
+    if (firstLine.trim().length > 0) return truncateTitle(firstLine);
+  }
+  return defaultTitle;
+}
+function parseJsonOrThrow(raw, filePath) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in session file: ${filePath}`);
+  }
+}
+
+// src/adapters/claude.ts
+var CLAUDE_EXTENSION = ".jsonl";
+var CLAUDE_TYPE_MARKERS = /* @__PURE__ */ new Set(["user", "assistant", "system", "tool_use", "tool_result"]);
+function extractText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n");
+}
+function titleFromFirstUserMessage(turns) {
+  const firstUser = turns.find((t) => t.role === "user" && t.content.trim().length > 0);
+  return resolveSessionTitle(void 0, firstUser?.content, "Claude Session");
+}
+function parseLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function eventToTurn(event) {
+  if (!event.message || !event.message.role) return null;
+  const role = event.message.role;
+  if (role !== "user" && role !== "assistant") return null;
+  const content = extractText(event.message.content);
+  if (content.trim().length === 0) return null;
+  return { role, content, timestamp: event.timestamp };
+}
+var claudeAdapter = {
+  name: "claude",
+  async detect(filePath) {
+    if (path9.extname(filePath).toLowerCase() !== CLAUDE_EXTENSION) return false;
+    const raw = await readFile8(filePath, "utf-8").catch(() => "");
+    const firstLine = raw.split("\n")[0].trim();
+    if (!firstLine.startsWith("{")) return false;
+    try {
+      const obj = JSON.parse(firstLine);
+      return typeof obj.type === "string" && CLAUDE_TYPE_MARKERS.has(obj.type);
+    } catch {
+      return false;
+    }
+  },
+  async parse(filePath) {
+    const raw = await readFile8(filePath, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length === 0) {
+      throw new Error(`Claude session file is empty: ${filePath}`);
+    }
+    const turns = [];
+    const timestamps = [];
+    for (const [index, line] of lines.entries()) {
+      const event = parseLine(line);
+      if (event === null) {
+        throw new Error(
+          `Malformed JSON on line ${index + 1} of Claude session: ${filePath}`
+        );
+      }
+      if (event.timestamp) timestamps.push(event.timestamp);
+      const turn = eventToTurn(event);
+      if (turn) turns.push(turn);
+    }
+    const title = titleFromFirstUserMessage(turns);
+    return {
+      title,
+      adapter: "claude",
+      startedAt: timestamps[0],
+      endedAt: timestamps[timestamps.length - 1],
+      participantIdentity: "Claude Code",
+      turns
+    };
+  }
+};
+
+// src/adapters/codex.ts
+import { readFile as readFile9 } from "fs/promises";
+import path10 from "path";
+var CODEX_EXTENSION = ".json";
+function unixToIso(ts) {
+  return new Date(ts * 1e3).toISOString();
+}
+function extractTurns(mapping) {
+  const turns = [];
+  for (const node of Object.values(mapping)) {
+    const msg = node.message;
+    if (!msg) continue;
+    const role = msg.author?.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const content = (msg.content?.parts ?? []).join("\n").trim();
+    if (content.length === 0) continue;
+    turns.push({
+      role,
+      content,
+      timestamp: msg.create_time != null ? unixToIso(msg.create_time) : void 0
+    });
+  }
+  turns.sort((a, b) => {
+    if (!a.timestamp || !b.timestamp) return 0;
+    return a.timestamp.localeCompare(b.timestamp);
+  });
+  return turns;
+}
+function isCodexExport(value) {
+  return Array.isArray(value) && value.length > 0 && typeof value[0].mapping === "object";
+}
+var codexAdapter = {
+  name: "codex",
+  async detect(filePath) {
+    if (path10.extname(filePath).toLowerCase() !== CODEX_EXTENSION) return false;
+    const raw = await readFile9(filePath, "utf-8").catch(() => "");
+    if (raw.trimStart()[0] !== "[") return false;
+    try {
+      return isCodexExport(JSON.parse(raw));
+    } catch {
+      return false;
+    }
+  },
+  async parse(filePath) {
+    const raw = await readFile9(filePath, "utf-8");
+    const parsed = parseJsonOrThrow(raw, filePath);
+    if (!isCodexExport(parsed)) {
+      throw new Error(
+        `Codex session file does not contain a conversation array: ${filePath}`
+      );
+    }
+    const conv = parsed[0];
+    const turns = extractTurns(conv.mapping ?? {});
+    const firstUser = turns.find((t) => t.role === "user");
+    return {
+      title: resolveSessionTitle(conv.title, firstUser?.content, "Codex Session"),
+      adapter: "codex",
+      startedAt: conv.create_time != null ? unixToIso(conv.create_time) : void 0,
+      endedAt: conv.update_time != null ? unixToIso(conv.update_time) : void 0,
+      participantIdentity: "OpenAI Codex",
+      turns
+    };
+  }
+};
+
+// src/adapters/cursor.ts
+import { readFile as readFile10 } from "fs/promises";
+import path11 from "path";
+var CURSOR_EXTENSION = ".json";
+function isTabsExport(value) {
+  return typeof value === "object" && value !== null && "tabs" in value && Array.isArray(value.tabs);
+}
+function isFlatExport(value) {
+  return typeof value === "object" && value !== null && "messages" in value && Array.isArray(value.messages);
+}
+function extractMessagesAndTitle(data) {
+  if (isTabsExport(data)) {
+    const tab = data.tabs[0];
+    return { messages: tab?.messages ?? [], title: tab?.title };
+  }
+  return { messages: data.messages, title: data.title };
+}
+function toTurns(messages) {
+  const turns = [];
+  for (const msg of messages) {
+    const role = msg.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const content = (msg.content ?? "").trim();
+    if (content.length === 0) continue;
+    turns.push({ role, content, timestamp: msg.timestamp });
+  }
+  return turns;
+}
+var cursorAdapter = {
+  name: "cursor",
+  async detect(filePath) {
+    if (path11.extname(filePath).toLowerCase() !== CURSOR_EXTENSION) return false;
+    const raw = await readFile10(filePath, "utf-8").catch(() => "");
+    if (raw.trimStart()[0] !== "{") return false;
+    try {
+      const parsed = JSON.parse(raw);
+      return isTabsExport(parsed) || isFlatExport(parsed);
+    } catch {
+      return false;
+    }
+  },
+  async parse(filePath) {
+    const raw = await readFile10(filePath, "utf-8");
+    const parsed = parseJsonOrThrow(raw, filePath);
+    if (!isTabsExport(parsed) && !isFlatExport(parsed)) {
+      throw new Error(
+        `Cursor session file does not match a known Cursor export schema: ${filePath}`
+      );
+    }
+    const { messages, title: rawTitle } = extractMessagesAndTitle(parsed);
+    const turns = toTurns(messages);
+    const firstUser = turns.find((t) => t.role === "user");
+    const timestamps = turns.filter((t) => t.timestamp != null).map((t) => t.timestamp);
+    return {
+      title: resolveSessionTitle(rawTitle, firstUser?.content, "Cursor Session"),
+      adapter: "cursor",
+      startedAt: timestamps[0],
+      endedAt: timestamps[timestamps.length - 1],
+      participantIdentity: "Cursor AI",
+      turns
+    };
+  }
+};
+
+// src/adapters/registry.ts
+var ADAPTERS = [claudeAdapter, codexAdapter, cursorAdapter];
+async function detectAdapter(filePath) {
+  for (const adapter of ADAPTERS) {
+    if (await adapter.detect(filePath)) return adapter;
+  }
+  return null;
+}
+async function parseSessionFile(filePath) {
+  const adapter = await detectAdapter(filePath);
+  if (!adapter) {
+    throw new Error(
+      `No session adapter recognised the file: ${filePath}
+Supported formats: ${ADAPTERS.map((a) => a.name).join(", ")}`
+    );
+  }
+  const session = await adapter.parse(filePath);
+  assertSessionHasUsableTurns(session, filePath);
+  return session;
+}
+function assertSessionHasUsableTurns(session, filePath) {
+  const hasUsableTurn = session.turns.some(
+    (t) => (t.role === "user" || t.role === "assistant") && t.content.trim().length > 0
+  );
+  if (!hasUsableTurn) {
+    throw new Error(
+      `${session.adapter} session has no usable turns: ${filePath}
+The file matches the ${session.adapter} export shape, but no user or assistant message with content was found. Re-export the session or delete the file if it is empty.`
+    );
+  }
+}
+function formatSessionAsMarkdown(session) {
+  const lines = [];
+  for (const turn of session.turns) {
+    const label = turn.role === "user" ? "User" : session.participantIdentity ?? "Assistant";
+    const heading = turn.timestamp ? `### ${label} _(${turn.timestamp})_` : `### ${label}`;
+    lines.push(heading);
+    lines.push("");
+    lines.push(turn.content);
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+
+// src/commands/ingest-session.ts
+function buildSessionFrontmatter(session, sourcePath) {
+  const meta = {
+    title: session.title,
+    source: sourcePath,
+    adapter: session.adapter,
+    ingestedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (session.startedAt) meta.sessionStartedAt = session.startedAt;
+  if (session.endedAt) meta.sessionEndedAt = session.endedAt;
+  if (session.participantIdentity) meta.participant = session.participantIdentity;
+  return buildFrontmatter(meta);
+}
+async function saveSessionSource(session, sourcePath) {
+  const frontmatter = buildSessionFrontmatter(session, sourcePath);
+  const body = formatSessionAsMarkdown(session);
+  const document = `${frontmatter}
+
+${body}
+`;
+  return saveSource(session.title, document, sourcePath);
+}
+async function ingestSessionFile(filePath) {
+  status("*", info(`Ingesting session: ${filePath}`));
+  const session = await parseSessionFile(filePath);
+  const savedPath = await saveSessionSource(session, filePath);
+  status(
+    "+",
+    success(
+      `Saved ${bold(path12.basename(savedPath))} [${session.adapter}] \u2192 ${source(savedPath)}`
+    )
+  );
+  return {
+    filename: path12.basename(savedPath),
+    adapter: session.adapter,
+    title: session.title,
+    source: filePath
+  };
+}
+async function listDirectoryFiles(dirPath) {
+  const entries = await readdir(dirPath);
+  const files = [];
+  for (const entry of entries) {
+    const full = path12.join(dirPath, entry);
+    const info2 = await stat(full);
+    if (info2.isFile()) files.push(full);
+  }
+  return files;
+}
+async function ingestDirectory(dirPath) {
+  const files = await listDirectoryFiles(dirPath);
+  if (files.length === 0) {
+    throw new Error(`No files found in directory: ${dirPath}`);
+  }
+  status("*", info(`Scanning ${files.length} file(s) in: ${dirPath}`));
+  let imported = 0;
+  let skipped = 0;
+  for (const file of files) {
+    try {
+      await ingestSessionFile(file);
+      imported++;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      status("!", warn(`Skipped ${path12.basename(file)}: ${message}`));
+      skipped++;
+    }
+  }
+  if (imported === 0) {
+    throw new Error(
+      `No sessions imported from ${dirPath} (${skipped} file(s) skipped). Check that at least one file is in a supported session format.`
+    );
+  }
+  status(
+    "\u2192",
+    dim(`Imported ${imported} session(s), skipped ${skipped}.`)
+  );
+}
+async function ingestSession(targetPath) {
+  const info2 = await stat(targetPath).catch(() => {
+    throw new Error(`Path not found: ${targetPath}`);
+  });
+  if (info2.isDirectory()) {
+    await ingestDirectory(targetPath);
+  } else {
+    await ingestSessionFile(targetPath);
+  }
+  status("\u2192", dim("Next: llmwiki compile"));
+}
+
 // src/commands/compile.ts
 import { existsSync as existsSync7 } from "fs";
 
 // src/compiler/index.ts
-import { readFile as readFile14 } from "fs/promises";
-import path21 from "path";
+import { readFile as readFile18 } from "fs/promises";
+import path26 from "path";
 
 // src/utils/state.ts
-import { readFile as readFile7, writeFile as writeFile3, rename as rename2, mkdir as mkdir3, copyFile } from "fs/promises";
+import { readFile as readFile11, writeFile as writeFile3, rename as rename2, mkdir as mkdir3, copyFile } from "fs/promises";
 import { existsSync } from "fs";
-import path8 from "path";
+import path13 from "path";
 function emptyState() {
   return { version: 1, indexHash: "", sources: {} };
 }
 async function readState(root) {
-  const filePath = path8.join(root, STATE_FILE);
+  const filePath = path13.join(root, STATE_FILE);
   if (!existsSync(filePath)) {
     return emptyState();
   }
   try {
-    const raw = await readFile7(filePath, "utf-8");
+    const raw = await readFile11(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     const bakPath = filePath + ".bak";
@@ -851,9 +1244,9 @@ async function readState(root) {
   }
 }
 async function writeState(root, state) {
-  const dir = path8.join(root, LLMWIKI_DIR);
+  const dir = path13.join(root, LLMWIKI_DIR);
   await mkdir3(dir, { recursive: true });
-  const filePath = path8.join(root, STATE_FILE);
+  const filePath = path13.join(root, STATE_FILE);
   const tmpPath = filePath + ".tmp";
   await writeFile3(tmpPath, JSON.stringify(state, null, 2), "utf-8");
   await rename2(tmpPath, filePath);
@@ -870,18 +1263,18 @@ async function removeSourceState(root, sourceFile) {
 }
 
 // src/compiler/source-state.ts
-import path10 from "path";
+import path15 from "path";
 
 // src/compiler/hasher.ts
-import { createHash } from "crypto";
-import { readFile as readFile8, readdir } from "fs/promises";
-import path9 from "path";
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile12, readdir as readdir2 } from "fs/promises";
+import path14 from "path";
 async function hashFile(filePath) {
-  const content = await readFile8(filePath, "utf-8");
-  return createHash("sha256").update(content).digest("hex");
+  const content = await readFile12(filePath, "utf-8");
+  return createHash2("sha256").update(content).digest("hex");
 }
 async function detectChanges(root, prevState) {
-  const sourcesPath = path9.join(root, SOURCES_DIR);
+  const sourcesPath = path14.join(root, SOURCES_DIR);
   const currentFiles = await listSourceFiles(sourcesPath);
   const changes = [];
   for (const file of currentFiles) {
@@ -894,14 +1287,14 @@ async function detectChanges(root, prevState) {
 }
 async function listSourceFiles(sourcesPath) {
   try {
-    const entries = await readdir(sourcesPath);
+    const entries = await readdir2(sourcesPath);
     return entries.filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
 }
 async function classifyFile(root, file, prevState) {
-  const filePath = path9.join(root, SOURCES_DIR, file);
+  const filePath = path14.join(root, SOURCES_DIR, file);
   const hash = await hashFile(filePath);
   const prev = prevState.sources[file];
   if (!prev) return "new";
@@ -924,7 +1317,7 @@ async function buildExtractionSourceStates(root, extractions) {
   return snapshot;
 }
 async function buildEntry(root, result, compiledAt) {
-  const filePath = path10.join(root, SOURCES_DIR, result.sourceFile);
+  const filePath = path15.join(root, SOURCES_DIR, result.sourceFile);
   const hash = await hashFile(filePath);
   return {
     hash,
@@ -1162,8 +1555,8 @@ async function callClaude(options) {
 }
 
 // src/utils/lock.ts
-import { open, readFile as readFile9, unlink, mkdir as mkdir4 } from "fs/promises";
-import path11 from "path";
+import { open, readFile as readFile13, unlink, mkdir as mkdir4 } from "fs/promises";
+import path16 from "path";
 var RECLAIM_SUFFIX = ".reclaim";
 var MAX_ACQUIRE_ATTEMPTS = 2;
 function isProcessAlive(pid) {
@@ -1175,8 +1568,8 @@ function isProcessAlive(pid) {
   }
 }
 async function acquireLock(root) {
-  const lockPath = path11.join(root, LOCK_FILE);
-  await mkdir4(path11.join(root, LLMWIKI_DIR), { recursive: true });
+  const lockPath = path16.join(root, LOCK_FILE);
+  await mkdir4(path16.join(root, LLMWIKI_DIR), { recursive: true });
   for (let attempt = 0; attempt < MAX_ACQUIRE_ATTEMPTS; attempt++) {
     const created = await tryCreateLock(lockPath);
     if (created) return true;
@@ -1239,7 +1632,7 @@ async function tryCreateLock(lockPath) {
 }
 async function isLockStale(lockPath) {
   try {
-    const content = await readFile9(lockPath, "utf-8");
+    const content = await readFile13(lockPath, "utf-8");
     const pid = parseInt(content.trim(), 10);
     if (isNaN(pid)) return true;
     return !isProcessAlive(pid);
@@ -1248,14 +1641,32 @@ async function isLockStale(lockPath) {
   }
 }
 async function releaseLock(root) {
-  const lockPath = path11.join(root, LOCK_FILE);
+  const lockPath = path16.join(root, LOCK_FILE);
   try {
     await unlink(lockPath);
   } catch {
   }
 }
 
+// src/utils/output-language.ts
+var LANG_ENV_VAR = "LLMWIKI_OUTPUT_LANG";
+function getOutputLanguage() {
+  const raw = process.env[LANG_ENV_VAR];
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function languageDirective() {
+  const lang = getOutputLanguage();
+  if (!lang) return "";
+  return `Write the output in ${lang}.`;
+}
+
 // src/compiler/prompts.ts
+function withLangLine(...lines) {
+  const lang = languageDirective();
+  return lang ? [...lines, lang] : lines;
+}
 var PROVENANCE_STATE_VALUES = [
   "extracted",
   "merged",
@@ -1310,10 +1721,6 @@ var CONCEPT_EXTRACTION_TOOL = {
                 required: ["slug"]
               },
               description: "Slugs of other concepts whose evidence contradicts this one."
-            },
-            inferred_paragraphs: {
-              type: "integer",
-              description: "Estimated number of paragraphs in the page that will be inferred rather than directly cited."
             }
           },
           required: ["concept", "summary", "is_new"]
@@ -1330,11 +1737,13 @@ Here is the existing wiki index \u2014 avoid duplicating concepts already covere
 
 ${existingIndex}` : "\n\nNo existing wiki pages yet.";
   return [
-    "You are a knowledge extraction engine. Analyze the following source document",
-    "and identify 3-8 distinct, meaningful concepts worth documenting as wiki pages.",
-    "Each concept should be a standalone topic that someone might look up.",
-    "Focus on key ideas, techniques, patterns, or entities \u2014 not trivial details.",
-    "Use the extract_concepts tool to return your findings.",
+    ...withLangLine(
+      "You are a knowledge extraction engine. Analyze the following source document",
+      "and identify 3-8 distinct, meaningful concepts worth documenting as wiki pages.",
+      "Each concept should be a standalone topic that someone might look up.",
+      "Focus on key ideas, techniques, patterns, or entities \u2014 not trivial details.",
+      "Use the extract_concepts tool to return your findings."
+    ),
     "",
     "For every concept, emit provenance metadata so downstream tools can reason",
     "about reliability:",
@@ -1344,8 +1753,6 @@ ${existingIndex}` : "\n\nNo existing wiki pages yet.";
     "    or 'ambiguous' if the source is contradictory or unclear.",
     "  - contradicted_by: slugs of other concepts (in this batch or the index)",
     "    whose evidence conflicts with this one.",
-    "  - inferred_paragraphs: estimated number of paragraphs in the resulting",
-    "    page that will be inferred rather than directly citable.",
     indexSection,
     "\n\n--- SOURCE DOCUMENT ---\n\n",
     sourceContent
@@ -1363,11 +1770,13 @@ Related wiki pages for cross-referencing:
 
 ${relatedPages}` : "";
   return [
-    `You are a wiki author. Write a clear, well-structured markdown page about "${concept}".`,
-    "Draw facts only from the provided source material.",
-    "Include a ## Sources section at the end listing the source document.",
-    "Suggest [[wikilinks]] to related concepts where appropriate.",
-    "Write in a neutral, informative tone. Be concise but thorough.",
+    ...withLangLine(
+      `You are a wiki author. Write a clear, well-structured markdown page about "${concept}".`,
+      "Draw facts only from the provided source material.",
+      "Include a ## Sources section at the end listing the source document.",
+      "Suggest [[wikilinks]] to related concepts where appropriate.",
+      "Write in a neutral, informative tone. Be concise but thorough."
+    ),
     "",
     "Source attribution: at the end of each prose paragraph, append a citation",
     "marker showing which source file(s) the paragraph drew from.",
@@ -1384,7 +1793,7 @@ ${relatedPages}` : "";
     "",
     "If a paragraph is your inference rather than a direct extraction, leave it",
     "uncited \u2014 downstream lint rules will count uncited paragraphs as 'inferred'",
-    "to compute the page's provenance metadata.",
+    "so lint can surface excess-inferred-paragraphs warnings on review.",
     existingSection,
     relatedSection,
     "\n\n--- SOURCE MATERIAL ---\n\n",
@@ -1416,20 +1825,21 @@ function mapRawConcept(c) {
     tags: Array.isArray(c.tags) ? c.tags : void 0,
     confidence: typeof c.confidence === "number" ? c.confidence : void 0,
     provenanceState: provenance,
-    contradictedBy: coerceContradictedBy(c.contradicted_by),
-    inferredParagraphs: typeof c.inferred_paragraphs === "number" && Number.isInteger(c.inferred_paragraphs) && c.inferred_paragraphs >= 0 ? c.inferred_paragraphs : void 0
+    contradictedBy: coerceContradictedBy(c.contradicted_by)
   };
 }
 function buildSeedPagePrompt(seed, rule, relatedPagesContent) {
   const minLinks = rule.minWikilinks;
   const linkExpectation = minLinks > 0 ? `Include at least ${minLinks} [[wikilinks]] to related pages.` : "Use [[wikilinks]] when referencing other pages.";
   return [
-    `You are a wiki author. Write a ${seed.kind} page titled "${seed.title}".`,
-    `Page-kind guidance: ${rule.description}`,
-    `Summary line for context: ${seed.summary}`,
-    "Draw facts only from the related wiki pages provided below.",
-    linkExpectation,
-    "Write in a neutral, informative tone. Be concise but thorough.",
+    ...withLangLine(
+      `You are a wiki author. Write a ${seed.kind} page titled "${seed.title}".`,
+      `Page-kind guidance: ${rule.description}`,
+      `Summary line for context: ${seed.summary}`,
+      "Draw facts only from the related wiki pages provided below.",
+      linkExpectation,
+      "Write in a neutral, informative tone. Be concise but thorough."
+    ),
     "\n\n--- RELATED PAGES ---\n\n",
     relatedPagesContent
   ].join("\n");
@@ -1491,8 +1901,8 @@ function buildDefaultSchema() {
 
 // src/schema/loader.ts
 import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile10 } from "fs/promises";
-import path12 from "path";
+import { readFile as readFile14 } from "fs/promises";
+import path17 from "path";
 import yaml2 from "js-yaml";
 var SCHEMA_CANDIDATE_PATHS = [
   ".llmwiki/schema.json",
@@ -1503,7 +1913,7 @@ var SCHEMA_CANDIDATE_PATHS = [
 ];
 function findSchemaPath(root) {
   for (const candidate of SCHEMA_CANDIDATE_PATHS) {
-    const absolute = path12.join(root, candidate);
+    const absolute = path17.join(root, candidate);
     if (existsSync2(absolute)) return absolute;
   }
   return null;
@@ -1556,12 +1966,12 @@ async function loadSchema(root) {
   const defaults = buildDefaultSchema();
   const schemaPath = findSchemaPath(root);
   if (!schemaPath) return defaults;
-  const raw = await readFile10(schemaPath, "utf-8");
+  const raw = await readFile14(schemaPath, "utf-8");
   const parsed = parseSchemaFile(schemaPath, raw);
   return applyOverrides(defaults, parsed, schemaPath);
 }
 function defaultSchemaInitPath(root) {
-  return path12.join(root, SCHEMA_CANDIDATE_PATHS[0]);
+  return path17.join(root, SCHEMA_CANDIDATE_PATHS[0]);
 }
 
 // src/schema/helpers.ts
@@ -1733,7 +2143,7 @@ async function freezeFailedExtractions(root, results, frozenSlugs) {
 }
 
 // src/compiler/orphan.ts
-import path13 from "path";
+import path18 from "path";
 async function markOrphaned(root, sourceFile, state) {
   const sourceEntry = state.sources[sourceFile];
   if (!sourceEntry) return;
@@ -1759,7 +2169,7 @@ async function orphanUnownedFrozenPages(root, frozenSlugs) {
   }
 }
 async function orphanPage(root, slug, reason) {
-  const pagePath = path13.join(root, CONCEPTS_DIR, `${slug}.md`);
+  const pagePath = path18.join(root, CONCEPTS_DIR, `${slug}.md`);
   const content = await safeReadFile(pagePath);
   if (!content) return;
   const { meta } = parseFrontmatter(content);
@@ -1770,18 +2180,18 @@ async function orphanPage(root, slug, reason) {
 }
 
 // src/compiler/resolver.ts
-import { readdir as readdir2, readFile as readFile11 } from "fs/promises";
-import path14 from "path";
+import { readdir as readdir3, readFile as readFile15 } from "fs/promises";
+import path19 from "path";
 import { existsSync as existsSync3 } from "fs";
 async function buildTitleIndex(root) {
-  const conceptsDir = path14.join(root, CONCEPTS_DIR);
+  const conceptsDir = path19.join(root, CONCEPTS_DIR);
   if (!existsSync3(conceptsDir)) return [];
-  const files = await readdir2(conceptsDir);
+  const files = await readdir3(conceptsDir);
   const pages = [];
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = path14.join(conceptsDir, file);
-    const content = await readFile11(filePath, "utf-8");
+    const filePath = path19.join(conceptsDir, file);
+    const content = await readFile15(filePath, "utf-8");
     const { meta } = parseFrontmatter(content);
     if (meta.title && typeof meta.title === "string" && !meta.orphaned) {
       pages.push({
@@ -1867,7 +2277,7 @@ async function resolveInboundLinks(titleIndex, newSlugs) {
   let count = 0;
   for (const page of titleIndex) {
     if (newSlugs.includes(page.slug)) continue;
-    const content = await readFile11(page.filePath, "utf-8");
+    const content = await readFile15(page.filePath, "utf-8");
     const { body } = parseFrontmatter(content);
     const linked = addWikilinks(body, newTitles, page.title);
     if (linked !== body) {
@@ -1879,7 +2289,7 @@ async function resolveInboundLinks(titleIndex, newSlugs) {
   return count;
 }
 async function linkPage(page, titleIndex) {
-  const content = await readFile11(page.filePath, "utf-8");
+  const content = await readFile15(page.filePath, "utf-8");
   const { body } = parseFrontmatter(content);
   const linked = addWikilinks(body, titleIndex, page.title);
   if (linked === body) return false;
@@ -1889,18 +2299,18 @@ async function linkPage(page, titleIndex) {
 }
 
 // src/compiler/indexgen.ts
-import { readdir as readdir3 } from "fs/promises";
-import path15 from "path";
+import { readdir as readdir4 } from "fs/promises";
+import path20 from "path";
 async function generateIndex(root) {
   status("*", info("Generating index..."));
-  const conceptsPath = path15.join(root, CONCEPTS_DIR);
-  const queriesPath = path15.join(root, QUERIES_DIR);
+  const conceptsPath = path20.join(root, CONCEPTS_DIR);
+  const queriesPath = path20.join(root, QUERIES_DIR);
   const concepts = await collectPageSummaries(conceptsPath);
   const queries = await collectPageSummaries(queriesPath);
   concepts.sort((a, b) => a.title.localeCompare(b.title));
   queries.sort((a, b) => a.title.localeCompare(b.title));
   const indexContent = buildIndexContent(concepts, queries);
-  const indexPath = path15.join(root, INDEX_FILE);
+  const indexPath = path20.join(root, INDEX_FILE);
   await atomicWrite(indexPath, indexContent);
   const total = concepts.length + queries.length;
   status("+", success(`Index updated with ${total} pages.`));
@@ -1908,13 +2318,13 @@ async function generateIndex(root) {
 async function scanWikiPages(dirPath) {
   let files;
   try {
-    files = await readdir3(dirPath);
+    files = await readdir4(dirPath);
   } catch {
     return [];
   }
   const scanned = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path15.join(dirPath, file));
+    const content = await safeReadFile(path20.join(dirPath, file));
     const { meta } = parseFrontmatter(content);
     scanned.push({ slug: file.replace(/\.md$/, ""), meta });
   }
@@ -1949,9 +2359,45 @@ function buildIndexContent(concepts, queries) {
   return lines.join("\n");
 }
 
+// src/compiler/prompt-budget.ts
+var TRUNCATION_MARKER = "\n\n[\u2026truncated for prompt budget \u2014 see #39\u2026]";
+function resolvePromptBudgetChars() {
+  const raw = process.env[PROMPT_BUDGET_ENV_VAR];
+  if (!raw) return DEFAULT_PROMPT_BUDGET_CHARS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_PROMPT_BUDGET_CHARS;
+  return parsed;
+}
+function buildBudgetedCombinedContent(concept, slices) {
+  const budget = resolvePromptBudgetChars();
+  const totalRaw = slices.reduce((sum, s) => sum + s.content.length, 0);
+  if (totalRaw <= budget) {
+    return formatSlices(slices);
+  }
+  const perSource = Math.max(1, Math.floor(budget / slices.length));
+  warnTruncation(concept, totalRaw, slices.length, perSource, budget);
+  const trimmed = slices.map(
+    (s) => s.content.length > perSource ? { ...s, content: s.content.slice(0, perSource) + TRUNCATION_MARKER } : s
+  );
+  return formatSlices(trimmed);
+}
+function formatSlices(slices) {
+  return slices.map((s) => `--- SOURCE: ${s.file} ---
+
+${s.content}`).join("\n\n");
+}
+function warnTruncation(concept, totalRaw, sourceCount, perSource, budget) {
+  status(
+    "!",
+    warn(
+      `Combined source content for "${concept}" (${totalRaw.toLocaleString()} chars across ${sourceCount} sources) exceeds the ${budget.toLocaleString()}-char prompt budget; truncating each source to ~${perSource.toLocaleString()} chars. Raise via ${PROMPT_BUDGET_ENV_VAR} when running against larger-context models.`
+    )
+  );
+}
+
 // src/compiler/obsidian.ts
-import { readdir as readdir4 } from "fs/promises";
-import path16 from "path";
+import { readdir as readdir5 } from "fs/promises";
+import path21 from "path";
 var ABBREVIATION_MIN_WORDS = 3;
 var SWAP_CONJUNCTIONS = [" and ", " or "];
 function addObsidianMeta(frontmatter, conceptTitle, tags) {
@@ -1993,23 +2439,23 @@ function generateAbbreviation(title) {
   return abbreviation;
 }
 async function generateMOC(root) {
-  const conceptsPath = path16.join(root, CONCEPTS_DIR);
+  const conceptsPath = path21.join(root, CONCEPTS_DIR);
   const pages = await loadConceptPages(conceptsPath);
   const tagGroups = groupPagesByTag(pages);
   const content = buildMOCContent(tagGroups);
-  await atomicWrite(path16.join(root, MOC_FILE), content);
+  await atomicWrite(path21.join(root, MOC_FILE), content);
 }
 async function loadConceptPages(conceptsPath) {
   let files;
   try {
-    files = await readdir4(conceptsPath);
+    files = await readdir5(conceptsPath);
   } catch {
     return [];
   }
   const pages = [];
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const content = await safeReadFile(path16.join(conceptsPath, file));
+    const content = await safeReadFile(path21.join(conceptsPath, file));
     if (!content) continue;
     const { meta } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -2060,14 +2506,14 @@ function buildMOCContent(tagGroups) {
 }
 
 // src/utils/embeddings.ts
-import { readFile as readFile12, readdir as readdir5 } from "fs/promises";
+import { readFile as readFile16, readdir as readdir6 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path17 from "path";
+import path22 from "path";
 
 // src/utils/retrieval.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function hashChunkText(text) {
-  return createHash2("sha256").update(text, "utf8").digest("hex").slice(0, 16);
+  return createHash3("sha256").update(text, "utf8").digest("hex").slice(0, 16);
 }
 function splitIntoChunks(body) {
   const paragraphs = extractParagraphs(body);
@@ -2227,13 +2673,13 @@ function findTopKChunks(queryVec, chunks, k) {
   return scored.slice(0, k);
 }
 async function readEmbeddingStore(root) {
-  const filePath = path17.join(root, EMBEDDINGS_FILE);
+  const filePath = path22.join(root, EMBEDDINGS_FILE);
   if (!existsSync4(filePath)) return null;
-  const raw = await readFile12(filePath, "utf-8");
+  const raw = await readFile16(filePath, "utf-8");
   return JSON.parse(raw);
 }
 async function writeEmbeddingStore(root, store) {
-  const filePath = path17.join(root, EMBEDDINGS_FILE);
+  const filePath = path22.join(root, EMBEDDINGS_FILE);
   await atomicWrite(filePath, JSON.stringify(store, null, 2));
 }
 async function findRelevantPages(root, question) {
@@ -2265,10 +2711,10 @@ async function loadActiveStore(root, hasContent) {
 async function collectPageRecords(root) {
   const records = [];
   for (const dir of [CONCEPTS_DIR, QUERIES_DIR]) {
-    const absDir = path17.join(root, dir);
+    const absDir = path22.join(root, dir);
     let files;
     try {
-      files = await readdir5(absDir);
+      files = await readdir6(absDir);
     } catch {
       continue;
     }
@@ -2280,7 +2726,7 @@ async function collectPageRecords(root) {
   return records;
 }
 async function readPageRecord(absDir, file) {
-  const content = await safeReadFile(path17.join(absDir, file));
+  const content = await safeReadFile(path22.join(absDir, file));
   const { meta, body } = parseFrontmatter(content);
   if (meta.orphaned || typeof meta.title !== "string") return null;
   return {
@@ -2442,9 +2888,9 @@ function shouldRunEmbedding(modelChanged, toEmbed, previousEntries, previousChun
 }
 
 // src/compiler/candidates.ts
-import { readdir as readdir6, rename as rename3, unlink as unlink2, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
+import { readdir as readdir7, rename as rename3, unlink as unlink2, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
-import path18 from "path";
+import path23 from "path";
 import { randomBytes } from "crypto";
 var ID_SUFFIX_BYTES = 4;
 var CANDIDATE_EXT = ".json";
@@ -2453,10 +2899,10 @@ function buildCandidateId(slug) {
   return `${slug}-${suffix}`;
 }
 function candidatePath(root, id) {
-  return path18.join(root, CANDIDATES_DIR, `${id}${CANDIDATE_EXT}`);
+  return path23.join(root, CANDIDATES_DIR, `${id}${CANDIDATE_EXT}`);
 }
 function archivePath(root, id) {
-  return path18.join(root, CANDIDATES_ARCHIVE_DIR, `${id}${CANDIDATE_EXT}`);
+  return path23.join(root, CANDIDATES_ARCHIVE_DIR, `${id}${CANDIDATE_EXT}`);
 }
 async function writeCandidate(root, draft) {
   const candidate = {
@@ -2468,7 +2914,8 @@ async function writeCandidate(root, draft) {
     body: draft.body,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...draft.sourceStates ? { sourceStates: draft.sourceStates } : {},
-    ...draft.schemaViolations ? { schemaViolations: draft.schemaViolations } : {}
+    ...draft.schemaViolations ? { schemaViolations: draft.schemaViolations } : {},
+    ...draft.provenanceViolations ? { provenanceViolations: draft.provenanceViolations } : {}
   };
   await atomicWrite(candidatePath(root, candidate.id), JSON.stringify(candidate, null, 2));
   return candidate;
@@ -2507,9 +2954,9 @@ 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 = path18.join(root, CANDIDATES_DIR);
+  const dir = path23.join(root, CANDIDATES_DIR);
   if (!existsSync5(dir)) return [];
-  const entries = await readdir6(dir, { withFileTypes: true });
+  const entries = await readdir7(dir, { withFileTypes: true });
   const candidates = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(CANDIDATE_EXT)) continue;
@@ -2534,7 +2981,7 @@ async function archiveCandidate(root, id) {
   const sourcePath = candidatePath(root, id);
   if (!existsSync5(sourcePath)) return false;
   const target = archivePath(root, id);
-  await mkdir5(path18.dirname(target), { recursive: true });
+  await mkdir5(path23.dirname(target), { recursive: true });
   try {
     await rename3(sourcePath, target);
   } catch {
@@ -2546,9 +2993,9 @@ async function archiveCandidate(root, id) {
 }
 
 // src/linter/rules.ts
-import { readdir as readdir7, readFile as readFile13 } from "fs/promises";
+import { readdir as readdir8, readFile as readFile17 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import path19 from "path";
+import path24 from "path";
 var MIN_BODY_LENGTH = 50;
 var WIKILINK_PATTERN2 = /\[\[([^\]]+)\]\]/g;
 var CITATION_PATTERN = /\^\[([^\]]+)\]/g;
@@ -2565,26 +3012,26 @@ function findMatchesInContent(content, pattern) {
 }
 async function readMarkdownFiles(dirPath) {
   if (!existsSync6(dirPath)) return [];
-  const entries = await readdir7(dirPath);
+  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 readFile13(filePath, "utf-8");
+      const filePath = path24.join(dirPath, fileName);
+      const content = await readFile17(filePath, "utf-8");
       return { filePath, content };
     })
   );
   return results;
 }
 async function collectAllPages(root) {
-  const conceptPages = await readMarkdownFiles(path19.join(root, CONCEPTS_DIR));
-  const queryPages = await readMarkdownFiles(path19.join(root, QUERIES_DIR));
+  const conceptPages = await readMarkdownFiles(path24.join(root, CONCEPTS_DIR));
+  const queryPages = await readMarkdownFiles(path24.join(root, QUERIES_DIR));
   return [...conceptPages, ...queryPages];
 }
 function buildPageSlugSet(pages) {
   const slugs = /* @__PURE__ */ new Set();
   for (const page of pages) {
-    const baseName = path19.basename(page.filePath, ".md");
+    const baseName = path24.basename(page.filePath, ".md");
     slugs.add(baseName.toLowerCase());
   }
   return slugs;
@@ -2731,9 +3178,8 @@ async function checkInferredWithoutCitations(root) {
   const pages = await collectAllPages(root);
   const results = [];
   for (const page of pages) {
-    const { meta, body } = parseFrontmatter(page.content);
-    const provenance = parseProvenanceMetadata(meta);
-    const inferred = provenance.inferredParagraphs ?? countUncitedProseParagraphs(body);
+    const { body } = parseFrontmatter(page.content);
+    const inferred = countUncitedProseParagraphs(body);
     if (inferred <= MAX_INFERRED_PARAGRAPHS_WITHOUT_CITATIONS) continue;
     results.push({
       rule: "excess-inferred-paragraphs",
@@ -2744,7 +3190,7 @@ async function checkInferredWithoutCitations(root) {
   }
   return results;
 }
-var PROSE_PARAGRAPH_LEAD = /^[A-Za-z]/;
+var PROSE_PARAGRAPH_LEAD = new RegExp("^\\p{L}", "u");
 function countUncitedProseParagraphs(body) {
   const paragraphs = body.split(/\n\s*\n/);
   let count = 0;
@@ -2767,18 +3213,7 @@ async function checkSchemaCrossLinks(root, schema) {
   const pages = await collectAllPages(root);
   const results = [];
   for (const page of pages) {
-    const { meta, body } = parseFrontmatter(page.content);
-    const kind = resolvePageKind(meta.kind, schema);
-    const rule = schema.kinds[kind];
-    if (rule.minWikilinks <= 0) continue;
-    const linkCount = countWikilinks(body);
-    if (linkCount >= rule.minWikilinks) continue;
-    results.push({
-      rule: "schema-cross-link-minimum",
-      severity: "warning",
-      file: page.filePath,
-      message: `Page kind "${kind}" requires at least ${rule.minWikilinks} [[wikilinks]] but only ${linkCount} found.`
-    });
+    results.push(...checkPageCrossLinks(page.content, page.filePath, schema));
   }
   return results;
 }
@@ -2819,13 +3254,24 @@ function countLines(content) {
 }
 async function checkBrokenCitations(root) {
   const pages = await collectAllPages(root);
-  const sourcesDir = path19.join(root, SOURCES_DIR);
+  const sourcesDir = path24.join(root, SOURCES_DIR);
   const results = [];
   const lineCountCache = /* @__PURE__ */ new Map();
   for (const page of pages) {
-    for (const { captured, line } of findMatchesInContent(page.content, CITATION_PATTERN)) {
-      await collectBrokenForMarker(captured, line, page.filePath, sourcesDir, lineCountCache, results);
-    }
+    const pageFindings = await checkPageBrokenCitations(
+      page.content,
+      page.filePath,
+      sourcesDir,
+      lineCountCache
+    );
+    results.push(...pageFindings);
+  }
+  return results;
+}
+async function checkPageBrokenCitations(content, filePath, sourcesDir, lineCountCache = /* @__PURE__ */ new Map()) {
+  const results = [];
+  for (const { captured, line } of findMatchesInContent(content, CITATION_PATTERN)) {
+    await collectBrokenForMarker(captured, line, filePath, sourcesDir, lineCountCache, results);
   }
   return results;
 }
@@ -2834,7 +3280,7 @@ async function collectBrokenForMarker(captured, line, pageFile, sourcesDir, line
     const trimmed = part.trim();
     if (trimmed.length === 0) continue;
     const filename = stripSpanSuffix(trimmed);
-    const citedPath = path19.join(sourcesDir, filename);
+    const citedPath = path24.join(sourcesDir, filename);
     if (!existsSync6(citedPath)) {
       out.push({
         rule: "broken-citation",
@@ -2870,25 +3316,30 @@ async function checkMalformedClaimCitations(root) {
   const pages = await collectAllPages(root);
   const results = [];
   for (const page of pages) {
-    for (const { captured, line } of findMatchesInContent(page.content, CITATION_PATTERN)) {
-      for (const part of captured.split(",")) {
-        if (!isMalformedCitationEntry(part)) continue;
-        results.push({
-          rule: "malformed-claim-citation",
-          severity: "error",
-          file: page.filePath,
-          message: `Malformed claim citation ^[${captured}] \u2014 expected file.md, file.md:N-N, or file.md#LN-LN`,
-          line
-        });
-      }
+    results.push(...checkPageMalformedCitations(page.content, page.filePath));
+  }
+  return results;
+}
+function checkPageMalformedCitations(content, filePath) {
+  const results = [];
+  for (const { captured, line } of findMatchesInContent(content, CITATION_PATTERN)) {
+    for (const part of captured.split(",")) {
+      if (!isMalformedCitationEntry(part)) continue;
+      results.push({
+        rule: "malformed-claim-citation",
+        severity: "error",
+        file: filePath,
+        message: `Malformed claim citation ^[${captured}] \u2014 expected file.md, file.md:N-N, or file.md#LN-LN`,
+        line
+      });
     }
   }
   return results;
 }
 
 // src/compiler/page-renderer.ts
-import { readdir as readdir8 } from "fs/promises";
-import path20 from "path";
+import { readdir as readdir9 } from "fs/promises";
+import path25 from "path";
 
 // src/compiler/provenance.ts
 function addProvenanceMeta(fields, concept) {
@@ -2901,9 +3352,6 @@ function addProvenanceMeta(fields, concept) {
   if (concept.contradictedBy && concept.contradictedBy.length > 0) {
     fields.contradictedBy = concept.contradictedBy;
   }
-  if (typeof concept.inferredParagraphs === "number") {
-    fields.inferredParagraphs = concept.inferredParagraphs;
-  }
 }
 function reportContradictionWarnings(conceptTitle, concept) {
   const refs = concept.contradictedBy;
@@ -2918,7 +3366,7 @@ function reportContradictionWarnings(conceptTitle, concept) {
 // src/compiler/page-renderer.ts
 var RELATED_PAGE_CONTEXT_LIMIT = 5;
 async function renderMergedPageContent(root, entry, schema) {
-  const pagePath = path20.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
+  const pagePath = path25.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
   const existingPage = await safeReadFile(pagePath);
   const relatedPages = await loadRelatedPages(root, entry.slug);
   const system = buildPagePrompt(
@@ -2957,17 +3405,17 @@ function buildMergedFrontmatter(entry, existingPage, schema) {
   return buildFrontmatter(frontmatterFields);
 }
 async function loadRelatedPages(root, excludeSlug) {
-  const conceptsPath = path20.join(root, CONCEPTS_DIR);
+  const conceptsPath = path25.join(root, CONCEPTS_DIR);
   let files;
   try {
-    files = await readdir8(conceptsPath);
+    files = await readdir9(conceptsPath);
   } catch {
     return "";
   }
   const related = files.filter((f) => f.endsWith(".md") && f !== `${excludeSlug}.md`).slice(0, RELATED_PAGE_CONTEXT_LIMIT);
   const contents = [];
   for (const f of related) {
-    const content = await safeReadFile(path20.join(conceptsPath, f));
+    const content = await safeReadFile(path25.join(conceptsPath, f));
     if (!content) continue;
     const { meta } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -3021,7 +3469,7 @@ async function generatePagesPhase(root, extractions, frozenSlugs, schema, option
       return entry;
     }))
   );
-  return { pages, errors, candidates };
+  return { pages, errors, candidates, seedSlugs: [] };
 }
 async function persistExtractionStates(root, extractions) {
   for (const result of extractions) {
@@ -3047,12 +3495,13 @@ function summarizeCompile(buckets, generation, extractions, options) {
       errors.push(`No concepts extracted from ${result.sourceFile}`);
     }
   }
+  const conceptSlugs = generation.pages.map((entry) => entry.slug);
   const baseResult = {
     compiled: buckets.toCompile.length,
     skipped: buckets.unchanged.length,
     deleted: buckets.deleted.length,
     concepts: generation.pages.map((entry) => entry.concept.concept),
-    pages: generation.pages.map((entry) => entry.slug),
+    pages: [...conceptSlugs, ...generation.seedSlugs],
     errors
   };
   if (options.review) {
@@ -3070,12 +3519,21 @@ async function runCompilePipeline(root, options) {
   if (buckets.toCompile.length === 0 && buckets.deleted.length === 0) {
     status("\u2713", success("Nothing to compile \u2014 all sources up to date."));
     if (!options.review) {
-      const emptyGeneration = { pages: [], errors: [], candidates: [] };
+      const emptyGeneration = {
+        pages: [],
+        errors: [],
+        candidates: [],
+        seedSlugs: []
+      };
       await generateSeedPages(root, schema, emptyGeneration);
-      await finalizeWiki(root, emptyGeneration.pages);
+      await finalizeWiki(root, emptyGeneration.pages, emptyGeneration.seedSlugs);
       return {
         ...emptyCompileResult(),
         skipped: buckets.unchanged.length,
+        // Surface seed-page slugs alongside any errors so downstream
+        // consumers (MCP, embeddings, programmatic callers) can see what
+        // landed even on the no-source-changes early-return path.
+        pages: [...emptyGeneration.seedSlugs],
         errors: emptyGeneration.errors
       };
     }
@@ -3099,7 +3557,7 @@ async function runCompilePipeline(root, options) {
     }
     await persistFrozenSlugs(root, frozenSlugs, extractions);
     await generateSeedPages(root, schema, generation);
-    await finalizeWiki(root, generation.pages);
+    await finalizeWiki(root, generation.pages, generation.seedSlugs);
   }
   return summarizeCompile(buckets, generation, extractions, options);
 }
@@ -3136,9 +3594,11 @@ async function runExtractionPhases(root, toCompile, state, allChanges) {
   }
   return extractions;
 }
-async function finalizeWiki(root, pages) {
-  const allChangedSlugs = pages.map((entry) => entry.slug);
-  const allNewSlugs = pages.filter((entry) => entry.concept.is_new).map((entry) => entry.slug);
+async function finalizeWiki(root, pages, seedSlugs = []) {
+  const conceptChangedSlugs = pages.map((entry) => entry.slug);
+  const conceptNewSlugs = pages.filter((entry) => entry.concept.is_new).map((entry) => entry.slug);
+  const allChangedSlugs = [...conceptChangedSlugs, ...seedSlugs];
+  const allNewSlugs = [...conceptNewSlugs, ...seedSlugs];
   if (allChangedSlugs.length > 0) {
     status("\u{1F517}", info("Resolving interlinks..."));
     await resolveLinks(root, allChangedSlugs, allNewSlugs);
@@ -3168,9 +3628,9 @@ function printChangesSummary(changes) {
 }
 async function extractForSource(root, sourceFile) {
   status("*", info(`Extracting: ${sourceFile}`));
-  const sourcePath = path21.join(root, SOURCES_DIR, sourceFile);
-  const sourceContent = await readFile14(sourcePath, "utf-8");
-  const existingIndex = await safeReadFile(path21.join(root, INDEX_FILE));
+  const sourcePath = path26.join(root, SOURCES_DIR, sourceFile);
+  const sourceContent = await readFile18(sourcePath, "utf-8");
+  const existingIndex = await safeReadFile(path26.join(root, INDEX_FILE));
   const concepts = await extractConcepts(sourceContent, existingIndex);
   if (concepts.length > 0) {
     const names = concepts.map((c) => c.concept).join(", ");
@@ -3193,13 +3653,11 @@ function reconcileConceptMetadata(existing, incoming) {
     }
   }
   reconciled.contradictedBy = refs.length > 0 ? refs : void 0;
-  if (typeof incoming.inferredParagraphs === "number") {
-    reconciled.inferredParagraphs = typeof existing.inferredParagraphs === "number" ? Math.max(existing.inferredParagraphs, incoming.inferredParagraphs) : incoming.inferredParagraphs;
-  }
   return reconciled;
 }
 function mergeExtractions(extractions, frozenSlugs) {
   const bySlug = /* @__PURE__ */ new Map();
+  const slicesBySlug = /* @__PURE__ */ new Map();
   for (const result of extractions) {
     if (result.concepts.length === 0) continue;
     for (const concept of result.concepts) {
@@ -3209,23 +3667,28 @@ function mergeExtractions(extractions, frozenSlugs) {
       if (existing) {
         existing.concept = reconcileConceptMetadata(existing.concept, concept);
         existing.sourceFiles.push(result.sourceFile);
-        existing.combinedContent += `
-
---- SOURCE: ${result.sourceFile} ---
-
-${result.sourceContent}`;
       } else {
         bySlug.set(slug, {
           slug,
           concept,
           sourceFiles: [result.sourceFile],
-          combinedContent: `--- SOURCE: ${result.sourceFile} ---
-
-${result.sourceContent}`
+          combinedContent: ""
         });
+        slicesBySlug.set(slug, []);
       }
+      slicesBySlug.get(slug).push({
+        file: result.sourceFile,
+        content: result.sourceContent
+      });
     }
   }
+  for (const merged of bySlug.values()) {
+    const slices = slicesBySlug.get(merged.slug) ?? [];
+    merged.combinedContent = buildBudgetedCombinedContent(
+      merged.concept.concept,
+      slices
+    );
+  }
   return Array.from(bySlug.values());
 }
 async function generateMergedPage(root, entry, schema, options, sourceStates) {
@@ -3233,13 +3696,18 @@ async function generateMergedPage(root, entry, schema, options, sourceStates) {
   if (options.review) {
     return await persistReviewCandidate(root, entry, fullPage, sourceStates, schema);
   }
-  const pagePath = path21.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
+  const pagePath = path26.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
   const error2 = await writePageIfValid(pagePath, fullPage, entry.concept.concept);
   return { error: error2 ?? void 0 };
 }
 async function persistReviewCandidate(root, entry, fullPage, sourceStates, schema) {
   const virtualPath = `wiki/concepts/${entry.slug}.md`;
-  const violations = checkPageCrossLinks(fullPage, virtualPath, schema);
+  const schemaViolations = checkPageCrossLinks(fullPage, virtualPath, schema);
+  const provenanceViolations = await collectCandidateProvenanceViolations(
+    root,
+    fullPage,
+    virtualPath
+  );
   const candidate = await writeCandidate(root, {
     title: entry.concept.concept,
     slug: entry.slug,
@@ -3247,21 +3715,35 @@ async function persistReviewCandidate(root, entry, fullPage, sourceStates, schem
     sources: entry.sourceFiles,
     body: fullPage,
     sourceStates: pickStatesForSources(sourceStates, entry.sourceFiles),
-    schemaViolations: violations.length > 0 ? violations : void 0
+    schemaViolations: schemaViolations.length > 0 ? schemaViolations : void 0,
+    provenanceViolations: provenanceViolations.length > 0 ? provenanceViolations : void 0
   });
   status("?", info(`Candidate ready: ${candidate.id} (${entry.slug})`));
   return { candidateId: candidate.id };
 }
+async function collectCandidateProvenanceViolations(root, fullPage, virtualPath) {
+  const malformed = checkPageMalformedCitations(fullPage, virtualPath);
+  const broken = await checkPageBrokenCitations(
+    fullPage,
+    virtualPath,
+    path26.join(root, SOURCES_DIR)
+  );
+  return [...malformed, ...broken];
+}
 async function generateSeedPages(root, schema, generation) {
   if (schema.seedPages.length === 0) return;
   for (const seed of schema.seedPages) {
-    const error2 = await generateSingleSeedPage(root, schema, seed);
-    if (error2) generation.errors.push(error2);
+    const result = await generateSingleSeedPage(root, schema, seed);
+    if (result.error) {
+      generation.errors.push(result.error);
+      continue;
+    }
+    generation.seedSlugs.push(result.slug);
   }
 }
 async function generateSingleSeedPage(root, schema, seed) {
   const slug = slugify(seed.title);
-  const pagePath = path21.join(root, CONCEPTS_DIR, `${slug}.md`);
+  const pagePath = path26.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);
@@ -3284,16 +3766,17 @@ async function generateSingleSeedPage(root, schema, seed) {
   const frontmatterFields = { ...typedFields };
   addObsidianMeta(frontmatterFields, seed.title, []);
   const frontmatter = buildFrontmatter(frontmatterFields);
-  return await writePageIfValid(pagePath, `${frontmatter}
+  const error2 = await writePageIfValid(pagePath, `${frontmatter}
 
 ${pageBody}
 `, seed.title);
+  return error2 ? { slug, error: error2 } : { slug };
 }
 async function loadSeedRelatedPages(root, slugs) {
   if (slugs.length === 0) return "";
   const contents = [];
   for (const slug of slugs) {
-    const pagePath = path21.join(root, CONCEPTS_DIR, `${slug}.md`);
+    const pagePath = path26.join(root, CONCEPTS_DIR, `${slug}.md`);
     const content = await safeReadFile(pagePath);
     if (content) contents.push(content);
   }
@@ -3348,7 +3831,7 @@ async function compileCommand(options = {}) {
 
 // src/commands/query.ts
 import { existsSync as existsSync8 } from "fs";
-import path22 from "path";
+import path27 from "path";
 var PAGE_DIRS = [CONCEPTS_DIR, QUERIES_DIR];
 var PAGE_SELECTION_TOOL = {
   name: "select_pages",
@@ -3405,7 +3888,7 @@ async function selectRelevantPages(root, question, debug) {
     const { pages: rawPages2, reasoning: reasoning2 } = await selectPages(question, filteredIndex);
     return { pages: rawPages2, rawPages: rawPages2, reasoning: reasoning2, chunks: [] };
   }
-  const indexContent = await safeReadFile(path22.join(root, INDEX_FILE));
+  const indexContent = await safeReadFile(path27.join(root, INDEX_FILE));
   const { pages: rawPages, reasoning } = await selectPages(question, indexContent);
   return { pages: rawPages.map((p) => slugify(p)), rawPages, reasoning, chunks: [] };
 }
@@ -3497,7 +3980,7 @@ async function loadSelectedPages(root, slugs) {
   for (const slug of slugs) {
     let content = "";
     for (const dir of PAGE_DIRS) {
-      const candidate = await safeReadFile(path22.join(root, dir, `${slug}.md`));
+      const candidate = await safeReadFile(path27.join(root, dir, `${slug}.md`));
       if (!candidate) continue;
       const { meta } = parseFrontmatter(candidate);
       if (meta.orphaned) continue;
@@ -3513,7 +3996,11 @@ ${content}`);
   }
   return sections.join("\n\n");
 }
-var ANSWER_SYSTEM_PROMPT = "You are a knowledge assistant. Answer the question using ONLY the wiki content provided. Cite specific pages using [[Page Title]] wikilinks. If the wiki doesn't contain enough information, say so.";
+var ANSWER_SYSTEM_PROMPT_BASE = "You are a knowledge assistant. Answer the question using ONLY the wiki content provided. Cite specific pages using [[Page Title]] wikilinks. If the wiki doesn't contain enough information, say so.";
+function buildAnswerSystemPrompt() {
+  const lang = languageDirective();
+  return lang ? `${ANSWER_SYSTEM_PROMPT_BASE} ${lang}` : ANSWER_SYSTEM_PROMPT_BASE;
+}
 async function callAnswerLLM(question, pagesContent, chunks, onToken) {
   const provenance = chunks.length > 0 ? buildChunkProvenance(chunks) : "";
   const userMessage = `Question: ${question}
@@ -3521,7 +4008,7 @@ async function callAnswerLLM(question, pagesContent, chunks, onToken) {
 Relevant wiki pages:
 ${pagesContent}${provenance}`;
   return callClaude({
-    system: ANSWER_SYSTEM_PROMPT,
+    system: buildAnswerSystemPrompt(),
     messages: [{ role: "user", content: userMessage }],
     stream: Boolean(onToken),
     onToken
@@ -3544,7 +4031,7 @@ function summarizeAnswer(answer) {
 }
 async function saveQueryPage(root, question, answer) {
   const slug = slugify(question);
-  const filePath = path22.join(root, QUERIES_DIR, `${slug}.md`);
+  const filePath = path27.join(root, QUERIES_DIR, `${slug}.md`);
   const frontmatter = buildFrontmatter({
     title: question,
     summary: summarizeAnswer(answer),
@@ -3570,7 +4057,7 @@ ${answer}
   return slug;
 }
 async function generateAnswer(root, question, options = {}) {
-  if (!existsSync8(path22.join(root, INDEX_FILE))) {
+  if (!existsSync8(path27.join(root, INDEX_FILE))) {
     throw new Error("Wiki index not found. Run `llmwiki compile` first.");
   }
   const selection = await selectRelevantPages(root, question, Boolean(options.debug));
@@ -3598,7 +4085,7 @@ function buildEmptyResult(selection) {
   };
 }
 async function queryCommand(root, question, options) {
-  if (!existsSync8(path22.join(root, INDEX_FILE))) {
+  if (!existsSync8(path27.join(root, INDEX_FILE))) {
     status("!", error("Wiki index not found. Run `llmwiki compile` first."));
     return;
   }
@@ -3649,10 +4136,10 @@ var DEBUG_CHUNK_PREVIEW_CHARS = 120;
 // src/commands/watch.ts
 import { watch as chokidarWatch } from "chokidar";
 import { existsSync as existsSync9 } from "fs";
-import path23 from "path";
+import path28 from "path";
 var DEBOUNCE_MS = 500;
 async function watchCommand() {
-  const sourcesPath = path23.resolve(SOURCES_DIR);
+  const sourcesPath = path28.resolve(SOURCES_DIR);
   if (!existsSync9(sourcesPath)) {
     status(
       "!",
@@ -3687,7 +4174,7 @@ async function watchCommand() {
   const scheduleCompile = (eventPath, event) => {
     status(
       "~",
-      dim(`${event}: ${path23.basename(eventPath)}`)
+      dim(`${event}: ${path28.basename(eventPath)}`)
     );
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(triggerCompile, DEBOUNCE_MS);
@@ -3771,10 +4258,388 @@ async function lintCommand() {
   }
 }
 
+// src/commands/export.ts
+import path30 from "path";
+import { createRequire } from "module";
+
+// src/export/collect.ts
+import { readdir as readdir10, readFile as readFile19 } from "fs/promises";
+import path29 from "path";
+var WIKILINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+function extractWikilinkSlugs(body) {
+  const slugs = /* @__PURE__ */ new Set();
+  let match;
+  while ((match = WIKILINK_RE.exec(body)) !== null) {
+    slugs.add(slugify(match[1].trim()));
+  }
+  return [...slugs];
+}
+async function parsePageFile(filePath, slug, pageDirectory) {
+  let raw;
+  try {
+    raw = await readFile19(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const { meta, body } = parseFrontmatter(raw);
+  if (!meta.title || typeof meta.title !== "string") return null;
+  if (meta.orphaned === true) return null;
+  return {
+    title: meta.title,
+    slug,
+    pageDirectory,
+    summary: typeof meta.summary === "string" ? meta.summary : "",
+    sources: Array.isArray(meta.sources) ? meta.sources.filter((s) => typeof s === "string") : [],
+    tags: Array.isArray(meta.tags) ? meta.tags.filter((t) => typeof t === "string") : [],
+    createdAt: typeof meta.createdAt === "string" ? meta.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: typeof meta.updatedAt === "string" ? meta.updatedAt : (/* @__PURE__ */ new Date()).toISOString(),
+    links: extractWikilinkSlugs(body),
+    body
+  };
+}
+async function collectFromDir(dirPath, pageDirectory) {
+  let files;
+  try {
+    files = await readdir10(dirPath);
+  } catch {
+    return [];
+  }
+  const pages = [];
+  for (const file of files.filter((f) => f.endsWith(".md"))) {
+    const slug = file.replace(/\.md$/, "");
+    const page = await parsePageFile(path29.join(dirPath, file), slug, pageDirectory);
+    if (page) pages.push(page);
+  }
+  return pages;
+}
+async function collectExportPages(root) {
+  const conceptsPath = path29.join(root, CONCEPTS_DIR);
+  const queriesPath = path29.join(root, QUERIES_DIR);
+  const [concepts, queries] = await Promise.all([
+    collectFromDir(conceptsPath, "concepts"),
+    collectFromDir(queriesPath, "queries")
+  ]);
+  const all = [...concepts, ...queries];
+  all.sort((a, b) => a.title.localeCompare(b.title));
+  return all;
+}
+
+// src/export/llms-txt.ts
+function pageRelativePath(page) {
+  return `wiki/${page.pageDirectory}/${page.slug}.md`;
+}
+function buildEntryNote(page) {
+  const parts = [];
+  if (page.summary) parts.push(page.summary);
+  if (page.tags.length > 0) parts.push(`tags: ${page.tags.join(", ")}`);
+  if (page.sources.length > 0) parts.push(`sources: ${page.sources.join(", ")}`);
+  parts.push(`created: ${page.createdAt}`);
+  parts.push(`updated: ${page.updatedAt}`);
+  return parts.join(" | ");
+}
+function formatPageEntry(page) {
+  const note = buildEntryNote(page);
+  return `- [${page.title}](${pageRelativePath(page)}): ${note}`;
+}
+function buildSection(heading, pages) {
+  if (pages.length === 0) return [];
+  return [`## ${heading}`, "", ...pages.map(formatPageEntry), ""];
+}
+function buildLlmsTxt(pages, projectTitle) {
+  const concepts = pages.filter((p) => p.pageDirectory === "concepts");
+  const queries = pages.filter((p) => p.pageDirectory === "queries");
+  const lines = [
+    `# ${projectTitle}`,
+    "",
+    `> ${pages.length} pages \u2014 exported ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    ...buildSection("Concepts", concepts),
+    ...buildSection("Saved Queries", queries)
+  ];
+  return lines.join("\n");
+}
+function buildLlmsFullTxt(pages, projectTitle) {
+  const sections = [buildLlmsTxt(pages, projectTitle)];
+  for (const page of pages) {
+    const tags = page.tags.length > 0 ? `
+Tags: ${page.tags.join(", ")}` : "";
+    const sources = page.sources.length > 0 ? `
+Sources: ${page.sources.join(", ")}` : "";
+    const header2 = [
+      "---",
+      `## ${page.title}`,
+      `> ${page.summary}${tags}${sources}`,
+      `Created: ${page.createdAt} | Updated: ${page.updatedAt}`,
+      ""
+    ].join("\n");
+    sections.push(`${header2}
+${page.body.trim()}
+`);
+  }
+  return sections.join("\n");
+}
+
+// src/export/json-export.ts
+function buildJsonExport(pages) {
+  const doc = {
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pageCount: pages.length,
+    pages
+  };
+  return JSON.stringify(doc, null, 2);
+}
+
+// src/export/json-ld.ts
+var LOCAL_BASE = "urn:llmwiki:";
+function pageIri(slug) {
+  return `${LOCAL_BASE}${slug}`;
+}
+function pageToJsonLd(page) {
+  const node = {
+    "@id": pageIri(page.slug),
+    "@type": "Article",
+    name: page.title,
+    description: page.summary,
+    dateCreated: page.createdAt,
+    dateModified: page.updatedAt
+  };
+  if (page.tags.length > 0) {
+    node["keywords"] = page.tags;
+  }
+  if (page.sources.length > 0) {
+    node["isBasedOn"] = page.sources;
+  }
+  if (page.links.length > 0) {
+    node["mentions"] = page.links.map((slug) => ({ "@id": pageIri(slug) }));
+  }
+  return node;
+}
+function buildJsonLd(pages) {
+  const doc = {
+    "@context": "https://schema.org",
+    "@graph": pages.map(pageToJsonLd)
+  };
+  return JSON.stringify(doc, null, 2);
+}
+
+// src/export/graphml.ts
+var XML_ESCAPES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&apos;"
+};
+function escapeXml(value) {
+  return value.replace(/[&<>"']/g, (ch) => XML_ESCAPES[ch] ?? ch);
+}
+var KEY_DEFS = [
+  '<key id="title"     for="node" attr.name="title"     attr.type="string"/>',
+  '<key id="summary"   for="node" attr.name="summary"   attr.type="string"/>',
+  '<key id="tags"      for="node" attr.name="tags"      attr.type="string"/>',
+  '<key id="sources"   for="node" attr.name="sources"   attr.type="string"/>',
+  '<key id="createdAt" for="node" attr.name="createdAt" attr.type="string"/>',
+  '<key id="updatedAt" for="node" attr.name="updatedAt" attr.type="string"/>'
+].join("\n  ");
+function pageToNode(page) {
+  const tags = page.tags.join(", ");
+  const sources = page.sources.join(", ");
+  return [
+    `  <node id="${escapeXml(page.slug)}">`,
+    `    <data key="title">${escapeXml(page.title)}</data>`,
+    `    <data key="summary">${escapeXml(page.summary)}</data>`,
+    `    <data key="tags">${escapeXml(tags)}</data>`,
+    `    <data key="sources">${escapeXml(sources)}</data>`,
+    `    <data key="createdAt">${escapeXml(page.createdAt)}</data>`,
+    `    <data key="updatedAt">${escapeXml(page.updatedAt)}</data>`,
+    `  </node>`
+  ].join("\n");
+}
+function pageToEdges(page, knownSlugs) {
+  return page.links.filter((slug) => knownSlugs.has(slug)).map(
+    (slug) => `  <edge source="${escapeXml(page.slug)}" target="${escapeXml(slug)}"/>`
+  );
+}
+function buildGraphml(pages) {
+  const knownSlugs = new Set(pages.map((p) => p.slug));
+  const nodes = pages.map(pageToNode).join("\n");
+  const edges = pages.flatMap((p) => pageToEdges(p, knownSlugs)).join("\n");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<graphml xmlns="http://graphml.graphdrawing.org/graphml"',
+    '         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"',
+    '         xsi:schemaLocation="http://graphml.graphdrawing.org/graphml',
+    '           http://graphml.graphdrawing.org/graphml/1.0/graphml.xsd">',
+    `  ${KEY_DEFS}`,
+    '  <graph id="wiki" edgedefault="directed">',
+    nodes,
+    edges,
+    "  </graph>",
+    "</graphml>",
+    ""
+  ].join("\n");
+}
+
+// src/export/marp.ts
+var SLIDE_BODY_MAX_CHARS = 300;
+function extractFirstParagraph(body) {
+  const trimmed = body.trim();
+  const firstBlock = trimmed.split(/\n\s*\n/)[0] ?? "";
+  const stripped = firstBlock.replace(/^#{1,6}\s+/gm, "").replace(/^[-*+]\s+/gm, "").trim();
+  if (stripped.length <= SLIDE_BODY_MAX_CHARS) return stripped;
+  return `${stripped.slice(0, SLIDE_BODY_MAX_CHARS)}\u2026`;
+}
+function buildSpeakerNotes(page) {
+  const parts = [`created: ${page.createdAt}`, `updated: ${page.updatedAt}`];
+  if (page.sources.length > 0) parts.push(`sources: ${page.sources.join(", ")}`);
+  return `<!-- ${parts.join(" | ")} -->`;
+}
+function pageToSlide(page) {
+  const tagLine = page.tags.length > 0 ? `
+_Tags: ${page.tags.join(", ")}_` : "";
+  const excerpt = extractFirstParagraph(page.body);
+  const notes = buildSpeakerNotes(page);
+  return [
+    `## ${page.title}`,
+    "",
+    `> ${page.summary}${tagLine}`,
+    "",
+    excerpt,
+    "",
+    notes
+  ].join("\n");
+}
+function filterBySource(pages, source2) {
+  if (source2 === "all") return pages;
+  return pages.filter((p) => p.pageDirectory === source2);
+}
+function buildMarp(pages, projectTitle, source2 = "all") {
+  const filtered = filterBySource(pages, source2);
+  const frontmatter = [
+    "---",
+    "marp: true",
+    "theme: default",
+    "paginate: true",
+    `title: "${projectTitle}"`,
+    "---"
+  ].join("\n");
+  const titleSlide = [
+    "",
+    `# ${projectTitle}`,
+    "",
+    `${filtered.length} pages | ${(/* @__PURE__ */ new Date()).toISOString()}`
+  ].join("\n");
+  const slides = filtered.map((p) => `---
+
+${pageToSlide(p)}`);
+  return [frontmatter, titleSlide, ...slides, ""].join("\n\n");
+}
+
+// src/export/types.ts
+var MARP_SOURCES = ["concepts", "queries", "all"];
+var EXPORT_TARGETS = [
+  "llms-txt",
+  "llms-full-txt",
+  "json",
+  "json-ld",
+  "graphml",
+  "marp"
+];
+
+// src/commands/export.ts
+var require2 = createRequire(import.meta.url);
+var EXPORT_DIR = "dist/exports";
+var TARGET_FILENAMES = {
+  "llms-txt": "llms.txt",
+  "llms-full-txt": "llms-full.txt",
+  json: "wiki.json",
+  "json-ld": "wiki.jsonld",
+  graphml: "wiki.graphml",
+  marp: "wiki.md"
+};
+function resolveProjectTitle(root) {
+  try {
+    const pkg = require2(path30.join(root, "package.json"));
+    return typeof pkg.name === "string" ? pkg.name : "Knowledge Wiki";
+  } catch {
+    return "Knowledge Wiki";
+  }
+}
+function isValidTarget(value) {
+  return EXPORT_TARGETS.includes(value);
+}
+function isValidMarpSource(value) {
+  return MARP_SOURCES.includes(value);
+}
+function resolveMarpSource(rawSource) {
+  if (!rawSource) return "all";
+  if (!isValidMarpSource(rawSource)) {
+    throw new Error(
+      `Unknown --source value "${rawSource}". Valid values: ${MARP_SOURCES.join(", ")}`
+    );
+  }
+  return rawSource;
+}
+function buildContent(target, pages, projectTitle, marpSource) {
+  switch (target) {
+    case "llms-txt":
+      return buildLlmsTxt(pages, projectTitle);
+    case "llms-full-txt":
+      return buildLlmsFullTxt(pages, projectTitle);
+    case "json":
+      return buildJsonExport(pages);
+    case "json-ld":
+      return buildJsonLd(pages);
+    case "graphml":
+      return buildGraphml(pages);
+    case "marp":
+      return buildMarp(pages, projectTitle, marpSource);
+  }
+}
+function computeReportedPageCount(pages, targets, marpSource) {
+  const onlyMarpTarget = targets.length === 1 && targets[0] === "marp";
+  if (onlyMarpTarget && marpSource !== "all") {
+    return pages.filter((p) => p.pageDirectory === marpSource).length;
+  }
+  return pages.length;
+}
+async function runExport(root, options = {}) {
+  const pages = await collectExportPages(root);
+  const projectTitle = resolveProjectTitle(root);
+  const targets = resolveTargets(options.target);
+  const marpSource = resolveMarpSource(options.source);
+  const written = [];
+  for (const target of targets) {
+    const content = buildContent(target, pages, projectTitle, marpSource);
+    const outPath = path30.join(root, EXPORT_DIR, TARGET_FILENAMES[target]);
+    await atomicWrite(outPath, content);
+    written.push(outPath);
+    status("+", success(`Exported ${target} \u2192 ${source(outPath)}`));
+  }
+  return { written, pageCount: computeReportedPageCount(pages, targets, marpSource) };
+}
+function resolveTargets(rawTarget) {
+  if (!rawTarget) return [...EXPORT_TARGETS];
+  if (!isValidTarget(rawTarget)) {
+    throw new Error(
+      `Unknown export target "${rawTarget}". Valid targets: ${EXPORT_TARGETS.join(", ")}`
+    );
+  }
+  return [rawTarget];
+}
+async function exportCommand(root, options) {
+  header("Exporting wiki");
+  const { written, pageCount } = await runExport(root, options);
+  status(
+    "\u2713",
+    success(`Done \u2014 ${pageCount} pages exported to ${written.length} file(s).`)
+  );
+}
+
 // src/commands/schema.ts
 import { existsSync as existsSync10 } from "fs";
 import { mkdir as mkdir6, writeFile as writeFile5 } from "fs/promises";
-import path24 from "path";
+import path31 from "path";
 async function schemaInitCommand() {
   const root = process.cwd();
   const defaults = buildDefaultSchema();
@@ -3783,7 +4648,7 @@ async function schemaInitCommand() {
     status("!", warn(`Schema file already exists at ${targetPath}`));
     return;
   }
-  await mkdir6(path24.dirname(targetPath), { recursive: true });
+  await mkdir6(path31.dirname(targetPath), { recursive: true });
   const serializable = {
     version: defaults.version,
     defaultKind: defaults.defaultKind,
@@ -3839,10 +4704,17 @@ async function reviewShowCommand(id) {
       status("!", warn(`[${v.severity}] ${v.message}`));
     }
   }
+  if (candidate.provenanceViolations && candidate.provenanceViolations.length > 0) {
+    console.log();
+    header("Provenance violations");
+    for (const v of candidate.provenanceViolations) {
+      status("!", warn(`[${v.severity}] ${v.message}`));
+    }
+  }
 }
 
 // src/commands/review-approve.ts
-import path25 from "path";
+import path32 from "path";
 
 // src/commands/review-helpers.ts
 async function runReviewUnderLock(id, underLock) {
@@ -3874,7 +4746,7 @@ async function approveUnderLock(root, id) {
     process.exitCode = 1;
     return;
   }
-  const pagePath = path25.join(root, CONCEPTS_DIR, `${candidate.slug}.md`);
+  const pagePath = path32.join(root, CONCEPTS_DIR, `${candidate.slug}.md`);
   await atomicWrite(pagePath, candidate.body);
   status("+", success(`Approved \u2192 ${source(pagePath)}`));
   await persistCandidateSourceStates(root, candidate);
@@ -3934,7 +4806,7 @@ import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/tools.ts
-import path26 from "path";
+import path33 from "path";
 import { z } from "zod";
 
 // src/mcp/provider-check.ts
@@ -4070,7 +4942,7 @@ async function pickSearchSlugs(root, question) {
     if (candidates.length > 0) return candidates.map((c) => c.slug);
   } catch {
   }
-  const indexContent = await safeReadFile(path26.join(root, INDEX_FILE));
+  const indexContent = await safeReadFile(path33.join(root, INDEX_FILE));
   const { pages } = await selectPages(question, indexContent);
   return pages;
 }
@@ -4129,8 +5001,8 @@ function registerStatusTool(server, root) {
   );
 }
 async function collectStatus(root) {
-  const concepts = await collectPageSummaries(path26.join(root, CONCEPTS_DIR));
-  const queries = await collectPageSummaries(path26.join(root, QUERIES_DIR));
+  const concepts = await collectPageSummaries(path33.join(root, CONCEPTS_DIR));
+  const queries = await collectPageSummaries(path33.join(root, QUERIES_DIR));
   const state = await readState(root);
   const changes = await detectChanges(root, state);
   const orphans = await findOrphanedSlugs(root);
@@ -4147,7 +5019,7 @@ async function collectStatus(root) {
   };
 }
 async function findOrphanedSlugs(root) {
-  const scanned = await scanWikiPages(path26.join(root, CONCEPTS_DIR));
+  const scanned = await scanWikiPages(path33.join(root, CONCEPTS_DIR));
   return scanned.filter(({ meta }) => meta.orphaned).map(({ slug }) => slug);
 }
 async function loadPageRecords(root, slugs) {
@@ -4160,7 +5032,7 @@ async function loadPageRecords(root, slugs) {
 }
 async function readPage(root, slug) {
   for (const dir of PAGE_DIRS2) {
-    const content = await safeReadFile(path26.join(root, dir, `${slug}.md`));
+    const content = await safeReadFile(path33.join(root, dir, `${slug}.md`));
     if (!content) continue;
     const { meta, body } = parseFrontmatter(content);
     if (meta.orphaned) continue;
@@ -4175,8 +5047,8 @@ async function readPage(root, slug) {
 }
 
 // src/mcp/resources.ts
-import path27 from "path";
-import { readdir as readdir9 } from "fs/promises";
+import path34 from "path";
+import { readdir as readdir11 } from "fs/promises";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 function jsonContent(uri, payload) {
   return {
@@ -4209,7 +5081,7 @@ function registerIndexResource(server, root) {
       mimeType: "text/markdown"
     },
     async (uri) => {
-      const content = await safeReadFile(path27.join(root, INDEX_FILE));
+      const content = await safeReadFile(path34.join(root, INDEX_FILE));
       return { contents: [markdownContent(uri, content)] };
     }
   );
@@ -4276,23 +5148,23 @@ function registerQueryResource(server, root) {
   );
 }
 async function listSources(root) {
-  const sourcesPath = path27.join(root, SOURCES_DIR);
+  const sourcesPath = path34.join(root, SOURCES_DIR);
   let files;
   try {
-    files = await readdir9(sourcesPath);
+    files = await readdir11(sourcesPath);
   } catch {
     return [];
   }
   const records = [];
   for (const file of files.filter((f) => f.endsWith(".md"))) {
-    const content = await safeReadFile(path27.join(sourcesPath, file));
+    const content = await safeReadFile(path34.join(sourcesPath, file));
     const { meta } = parseFrontmatter(content);
     records.push({ filename: file, ...meta });
   }
   return records;
 }
 async function loadPageWithMeta(root, dir, slug) {
-  const filePath = path27.join(root, dir, `${slug}.md`);
+  const filePath = path34.join(root, dir, `${slug}.md`);
   const content = await safeReadFile(filePath);
   if (!content) {
     throw new Error(`Page not found: ${dir}/${slug}.md`);
@@ -4301,10 +5173,10 @@ async function loadPageWithMeta(root, dir, slug) {
   return { slug, meta, body: body.trim() };
 }
 async function listPagesUnder(root, dir, scheme) {
-  const pagesPath = path27.join(root, dir);
+  const pagesPath = path34.join(root, dir);
   let files;
   try {
-    files = await readdir9(pagesPath);
+    files = await readdir11(pagesPath);
   } catch {
     return { resources: [] };
   }
@@ -4328,8 +5200,8 @@ async function startMCPServer(options) {
 }
 
 // src/cli.ts
-var require2 = createRequire(import.meta.url);
-var { version } = require2("../package.json");
+var require3 = createRequire2(import.meta.url);
+var { version } = require3("../package.json");
 var program = new Command();
 program.name("llmwiki").description("The knowledge compiler \u2014 raw sources in, interlinked wiki out").version(version);
 program.command("ingest <source>").description("Ingest a URL or local file into sources/").action(async (source2) => {
@@ -4340,11 +5212,23 @@ program.command("ingest <source>").description("Ingest a URL or local file into
     process.exit(1);
   }
 });
+program.command("ingest-session <path>").description("Ingest a coding-agent session export (Claude, Codex, Cursor) into sources/").action(async (targetPath) => {
+  try {
+    await ingestSession(targetPath);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
 program.command("compile").description("Compile sources/ into an interlinked wiki").option(
   "--review",
   "Write generated pages as review candidates under .llmwiki/candidates/ instead of mutating wiki/. Orphan-marking for deleted sources is deferred until the next non-review compile."
+).option(
+  "--lang <code>",
+  'Target language for generated wiki content (e.g. "Chinese", "ja", "zh-CN"). Equivalent to setting LLMWIKI_OUTPUT_LANG.'
 ).action(async (options) => {
   try {
+    applyLanguageOption(options.lang);
     requireProvider();
     await compileCommand({ review: options.review });
   } catch (err) {
@@ -4385,15 +5269,21 @@ reviewCommand.command("reject <id>").description("Reject a candidate and archive
     process.exit(1);
   }
 });
-program.command("query <question>").description("Ask a question against the wiki").option("--save", "Save the answer as a wiki page").option("--debug", "Print which pages and chunks were selected and their scores").action(async (question, options) => {
-  try {
-    requireProvider();
-    await queryCommand(process.cwd(), question, options);
-  } catch (err) {
-    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
-    process.exit(1);
+program.command("query <question>").description("Ask a question against the wiki").option("--save", "Save the answer as a wiki page").option("--debug", "Print which pages and chunks were selected and their scores").option(
+  "--lang <code>",
+  'Target language for the answer (e.g. "Chinese", "ja", "zh-CN"). Equivalent to setting LLMWIKI_OUTPUT_LANG.'
+).action(
+  async (question, options) => {
+    try {
+      applyLanguageOption(options.lang);
+      requireProvider();
+      await queryCommand(process.cwd(), question, options);
+    } catch (err) {
+      console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
   }
-});
+);
 program.command("watch").description("Watch sources/ and auto-recompile on changes").action(async () => {
   try {
     requireProvider();
@@ -4428,6 +5318,17 @@ schemaCmd.command("show").description("Print the resolved schema for this projec
     process.exit(1);
   }
 });
+program.command("export").description("Export wiki content to portable formats (llms.txt, JSON, GraphML, Marp, \u2026)").option("--target <name>", "Limit export to a single target format").option(
+  "--source <kind>",
+  "For marp target: which pages to include \u2014 concepts, queries, or all (default: all)"
+).action(async (options) => {
+  try {
+    await exportCommand(process.cwd(), options);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
 program.command("serve").description("Start an MCP server exposing wiki tools and resources over stdio").option("--root <dir>", "Project root directory", process.cwd()).action(async (options) => {
   try {
     await startMCPServer({ root: options.root, version });
@@ -4436,6 +5337,11 @@ program.command("serve").description("Start an MCP server exposing wiki tools an
     process.exit(1);
   }
 });
+function applyLanguageOption(lang) {
+  if (lang && lang.trim().length > 0) {
+    process.env.LLMWIKI_OUTPUT_LANG = lang.trim();
+  }
+}
 var PROVIDER_KEY_VARS2 = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY",