@swarmvaultai/engine 0.2.2 → 0.4.0

package/dist/index.js

@@ -1729,7 +1729,7 @@ import matter3 from "gray-matter";
 import ignore from "ignore";
 import { JSDOM as JSDOM2 } from "jsdom";
 import mime from "mime-types";
-import TurndownService from "turndown";
+import TurndownService2 from "turndown";
 
 // src/code-analysis.ts
 import fs6 from "fs/promises";
@@ -4504,8 +4504,11 @@ async function analyzeCodeSource(manifest, extractedText, schemaHash) {
 import fs7 from "fs/promises";
 import os from "os";
 import path7 from "path";
+import { Readable } from "stream";
+import { parse as parseCsvSync } from "csv-parse/sync";
 import { strFromU8, unzipSync } from "fflate";
 import { JSDOM } from "jsdom";
+import TurndownService from "turndown";
 import { z } from "zod";
 var imageVisionExtractionSchema = z.object({
   title: z.string().min(1).nullable().optional(),
@@ -4685,7 +4688,7 @@ function normalizePdfMetadata(raw) {
 function normalizeDocumentText(raw) {
   return raw.replace(/\r\n/g, "\n").split(/\n{2,}/).map((section) => normalizeWhitespace(section)).filter(Boolean).join("\n\n").trim();
 }
-function parseDocxCoreMetadata(bytes) {
+function parseOfficeCoreMetadata(bytes) {
   try {
     const archive = unzipSync(new Uint8Array(bytes));
     const coreXml = archive["docProps/core.xml"];
@@ -4725,6 +4728,122 @@ function parseDocxCoreMetadata(bytes) {
     return void 0;
   }
 }
+function decodeTextBytes(bytes) {
+  const text = bytes.toString("utf8");
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function normalizeTableCell(value) {
+  return normalizeWhitespace(String(value ?? ""));
+}
+function isNumericCell(value) {
+  return value.length > 0 && Number.isFinite(Number(value));
+}
+function detectHeaderRow(rows) {
+  if (!rows.length) {
+    return { headers: [], bodyRows: [] };
+  }
+  const firstRow = rows[0] ?? [];
+  const nonEmpty = firstRow.filter(Boolean);
+  const unique = new Set(nonEmpty);
+  const nonNumeric = nonEmpty.filter((value) => !isNumericCell(value));
+  const looksLikeHeader = nonEmpty.length > 0 && unique.size === nonEmpty.length && nonNumeric.length >= Math.ceil(nonEmpty.length / 2) && rows.length > 1;
+  if (looksLikeHeader) {
+    return {
+      headers: firstRow.map((value, index) => value || `column_${index + 1}`),
+      bodyRows: rows.slice(1)
+    };
+  }
+  const columnCount = Math.max(...rows.map((row) => row.length), 0);
+  return {
+    headers: Array.from({ length: columnCount }, (_, index) => `column_${index + 1}`),
+    bodyRows: rows
+  };
+}
+function columnHints(headers, rows) {
+  return headers.map((header, index) => {
+    const values = rows.map((row) => row[index] ?? "").map(normalizeTableCell).filter(Boolean);
+    if (!values.length) {
+      return null;
+    }
+    const uniqueValues = [...new Set(values)];
+    if (values.every(isNumericCell)) {
+      return `- ${header}: numeric`;
+    }
+    if (uniqueValues.length <= 6 && values.length >= uniqueValues.length) {
+      return `- ${header}: low-cardinality (${uniqueValues.slice(0, 6).join(", ")})`;
+    }
+    return null;
+  }).filter((item) => Boolean(item));
+}
+function markdownTable(headers, rows, rowLimit = 20) {
+  if (!headers.length) {
+    return ["No tabular preview available."];
+  }
+  const width = headers.length;
+  const lines = [`| ${headers.join(" | ")} |`, `| ${headers.map(() => "---").join(" | ")} |`];
+  for (const row of rows.slice(0, rowLimit)) {
+    const normalized = Array.from({ length: width }, (_, index) => normalizeTableCell(row[index] ?? ""));
+    lines.push(`| ${normalized.join(" | ")} |`);
+  }
+  return lines;
+}
+function zipEntryText(archive, entryPath) {
+  const entry = archive[entryPath];
+  return entry ? strFromU8(entry) : void 0;
+}
+function parseXmlDocument(xml) {
+  return new JSDOM(xml, { contentType: "text/xml" }).window.document;
+}
+function zipDirname(value) {
+  const index = value.lastIndexOf("/");
+  return index === -1 ? "" : value.slice(0, index);
+}
+function resolveZipTarget(basePath, target) {
+  return path7.posix.normalize(path7.posix.join(zipDirname(basePath), target));
+}
+function relationshipTargets(xml, basePath) {
+  const document = parseXmlDocument(xml);
+  const map = /* @__PURE__ */ new Map();
+  for (const node of Array.from(document.getElementsByTagName("*"))) {
+    if (node.localName !== "Relationship") {
+      continue;
+    }
+    const id = node.getAttribute("Id")?.trim();
+    const target = node.getAttribute("Target")?.trim();
+    const type = node.getAttribute("Type")?.trim() ?? "";
+    if (!id || !target) {
+      continue;
+    }
+    map.set(id, { target: resolveZipTarget(basePath, target), type });
+  }
+  return map;
+}
+function xmlTextNodes(xml, localName) {
+  const document = parseXmlDocument(xml);
+  const values = [];
+  for (const node of Array.from(document.getElementsByTagName("*"))) {
+    if (node.localName !== localName) {
+      continue;
+    }
+    const text = normalizeWhitespace(node.textContent ?? "");
+    if (text) {
+      values.push(text);
+    }
+  }
+  return values;
+}
+function firstHtmlHeading(html) {
+  const dom = new JSDOM(html);
+  const heading = dom.window.document.querySelector("h1, h2, h3");
+  const title = normalizeWhitespace(heading?.textContent ?? "");
+  return title || void 0;
+}
+function htmlToMarkdown(html) {
+  const dom = new JSDOM(html);
+  const turndown = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
+  const body = dom.window.document.body?.innerHTML ?? html;
+  return turndown.turndown(body).trim();
+}
 async function extractPdfText(input) {
   try {
     const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
@@ -4765,39 +4884,793 @@ async function extractPdfText(input) {
     };
   } catch (error) {
     return {
-      artifact: {
-        ...extractionMetadata("pdf", input.mimeType, "pdf_text"),
-        warnings: [`PDF text extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
-      }
+      artifact: {
+        ...extractionMetadata("pdf", input.mimeType, "pdf_text"),
+        warnings: [`PDF text extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractDocxText(input) {
+  try {
+    const mammoth = await import("mammoth");
+    const result = await mammoth.extractRawText({
+      buffer: input.bytes
+    });
+    const extractedText = normalizeDocumentText(result.value);
+    const warnings = result.messages.map((message) => normalizeWhitespace(message.message)).filter(Boolean).map((message) => truncate(message, 240));
+    const artifact = {
+      ...extractionMetadata("docx", input.mimeType, "docx_text"),
+      metadata: parseOfficeCoreMetadata(input.bytes),
+      warnings: warnings.length ? warnings : void 0
+    };
+    if (!extractedText) {
+      artifact.warnings = [...artifact.warnings ?? [], "DOCX text extraction completed but produced no extractable text."];
+    }
+    return {
+      extractedText: extractedText || void 0,
+      artifact
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("docx", input.mimeType, "docx_text"),
+        warnings: [`DOCX text extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractCsvText(input) {
+  try {
+    const rawText = decodeTextBytes(input.bytes);
+    const delimiter = input.fileName?.toLowerCase().endsWith(".tsv") || input.mimeType.includes("tab-separated") ? "	" : ",";
+    const parsed = parseCsvSync(rawText, {
+      delimiter,
+      relax_column_count: true,
+      skip_empty_lines: true,
+      trim: true
+    });
+    const rows = parsed.map((row) => row.map((value) => normalizeTableCell(value)));
+    const { headers, bodyRows } = detectHeaderRow(rows);
+    const hintLines = columnHints(headers, bodyRows);
+    const title = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0;
+    const extractedText = [
+      title ? `# ${title}` : null,
+      `Format: ${delimiter === "	" ? "TSV" : "CSV"}`,
+      `Rows: ${bodyRows.length}`,
+      `Columns: ${headers.length}`,
+      headers.length ? `Headers: ${headers.join(", ")}` : null,
+      "",
+      hintLines.length ? "## Column Hints" : null,
+      hintLines.length ? hintLines.join("\n") : null,
+      hintLines.length ? "" : null,
+      "## Preview",
+      ...markdownTable(headers, bodyRows)
+    ].filter((item) => Boolean(item)).join("\n").trim();
+    const artifact = {
+      ...extractionMetadata("csv", input.mimeType, "csv_text"),
+      metadata: {
+        format: delimiter === "	" ? "tsv" : "csv",
+        row_count: String(bodyRows.length),
+        column_count: String(headers.length),
+        headers: headers.join(", ")
+      }
+    };
+    return {
+      title,
+      extractedText,
+      artifact
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("csv", input.mimeType, "csv_text"),
+        warnings: [`CSV extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractXlsxText(input) {
+  try {
+    const XLSX = await import("xlsx");
+    const workbook = XLSX.read(input.bytes, { type: "buffer", cellFormula: false, cellHTML: false, cellStyles: false });
+    const allSheetNames = workbook.SheetNames;
+    const sheetNames = allSheetNames.slice(0, 10);
+    const sheetSections = [];
+    const metadata = {
+      sheet_count: String(allSheetNames.length),
+      sheet_names: allSheetNames.join(", ")
+    };
+    for (const sheetName of sheetNames) {
+      const sheet = workbook.Sheets[sheetName];
+      if (!sheet) {
+        continue;
+      }
+      const rows = XLSX.utils.sheet_to_json(sheet, {
+        header: 1,
+        raw: false,
+        defval: ""
+      }).map((row) => row.map((value) => normalizeTableCell(value)));
+      const { headers, bodyRows } = detectHeaderRow(rows);
+      sheetSections.push(`## Sheet: ${sheetName}`);
+      sheetSections.push(`Rows: ${bodyRows.length}`);
+      sheetSections.push(`Columns: ${headers.length}`);
+      sheetSections.push(...markdownTable(headers, bodyRows));
+      sheetSections.push("");
+    }
+    const title = normalizeWhitespace(String(workbook.Props?.Title ?? "")) || (input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0);
+    const extractedText = [
+      title ? `# ${title}` : null,
+      `Sheets: ${allSheetNames.length}`,
+      allSheetNames.length ? `Sheet Names: ${allSheetNames.join(", ")}` : null,
+      "",
+      ...sheetSections
+    ].filter((item) => Boolean(item)).join("\n").trim();
+    const warnings = allSheetNames.length > sheetNames.length ? ["Workbook preview truncated to the first 10 sheets."] : void 0;
+    return {
+      title,
+      extractedText,
+      artifact: {
+        ...extractionMetadata("xlsx", input.mimeType, "xlsx_text"),
+        metadata,
+        warnings
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("xlsx", input.mimeType, "xlsx_text"),
+        warnings: [`XLSX extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractPptxText(input) {
+  try {
+    const archive = unzipSync(new Uint8Array(input.bytes));
+    const presentationXml = zipEntryText(archive, "ppt/presentation.xml");
+    if (!presentationXml) {
+      throw new Error("Missing ppt/presentation.xml");
+    }
+    const relsXml = zipEntryText(archive, "ppt/_rels/presentation.xml.rels");
+    if (!relsXml) {
+      throw new Error("Missing ppt/_rels/presentation.xml.rels");
+    }
+    const rels = relationshipTargets(relsXml, "ppt/presentation.xml");
+    const document = parseXmlDocument(presentationXml);
+    const slideTargets = Array.from(document.getElementsByTagName("*")).filter((node) => node.localName === "sldId").map((node) => node.getAttribute("r:id")?.trim()).filter((value) => Boolean(value)).map((relationshipId) => rels.get(relationshipId)?.target).filter((value) => Boolean(value)).slice(0, 60);
+    const slideSections = [];
+    for (let index = 0; index < slideTargets.length; index += 1) {
+      const slidePath = slideTargets[index];
+      const slideXml = zipEntryText(archive, slidePath);
+      if (!slideXml) {
+        continue;
+      }
+      const slideTexts = xmlTextNodes(slideXml, "t");
+      const slideTitle = slideTexts[0] ?? `Slide ${index + 1}`;
+      slideSections.push(`## Slide ${index + 1}: ${slideTitle}`);
+      if (slideTexts.length) {
+        slideSections.push(slideTexts.join("\n"));
+      }
+      const slideRelsPath = `${zipDirname(slidePath)}/_rels/${path7.posix.basename(slidePath)}.rels`;
+      const slideRelsXml = zipEntryText(archive, slideRelsPath);
+      if (slideRelsXml) {
+        const slideRels = relationshipTargets(slideRelsXml, slidePath);
+        const notesTarget = [...slideRels.values()].find((entry) => entry.type.endsWith("/notesSlide"))?.target;
+        if (notesTarget) {
+          const notesXml = zipEntryText(archive, notesTarget);
+          const noteTexts = notesXml ? xmlTextNodes(notesXml, "t") : [];
+          if (noteTexts.length) {
+            slideSections.push("Notes:");
+            slideSections.push(noteTexts.join("\n"));
+          }
+        }
+      }
+      slideSections.push("");
+    }
+    const metadata = parseOfficeCoreMetadata(input.bytes);
+    const title = metadata?.title || (input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0);
+    const extractedText = [title ? `# ${title}` : null, `Slides: ${slideTargets.length}`, "", ...slideSections].filter((item) => Boolean(item)).join("\n").trim();
+    return {
+      title,
+      extractedText,
+      artifact: {
+        ...extractionMetadata("pptx", input.mimeType, "pptx_text"),
+        metadata: {
+          ...metadata ?? {},
+          slide_count: String(slideTargets.length)
+        },
+        warnings: Array.from(document.getElementsByTagName("*")).filter((node) => node.localName === "sldId").length > slideTargets.length ? ["Slide extraction truncated to the first 60 slides."] : void 0
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("pptx", input.mimeType, "pptx_text"),
+        warnings: [`PPTX extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractEpubChapters(input) {
+  try {
+    const archive = unzipSync(new Uint8Array(input.bytes));
+    const containerXml = zipEntryText(archive, "META-INF/container.xml");
+    if (!containerXml) {
+      throw new Error("Missing META-INF/container.xml");
+    }
+    const container = parseXmlDocument(containerXml);
+    const rootfile = Array.from(container.getElementsByTagName("*")).find((node) => node.localName === "rootfile");
+    const packagePath = rootfile?.getAttribute("full-path")?.trim();
+    if (!packagePath) {
+      throw new Error("EPUB container did not declare a package document.");
+    }
+    const packageXml = zipEntryText(archive, packagePath);
+    if (!packageXml) {
+      throw new Error(`Missing EPUB package document: ${packagePath}`);
+    }
+    const packageDocument = parseXmlDocument(packageXml);
+    const manifestEntries = new Map(
+      Array.from(packageDocument.getElementsByTagName("*")).filter((node) => node.localName === "item").map(
+        (node) => [
+          node.getAttribute("id")?.trim() ?? "",
+          {
+            href: node.getAttribute("href")?.trim() ?? "",
+            mediaType: node.getAttribute("media-type")?.trim() ?? "",
+            properties: node.getAttribute("properties")?.trim() ?? ""
+          }
+        ]
+      ).filter(([id, item]) => Boolean(id && item.href))
+    );
+    const spineIds = Array.from(packageDocument.getElementsByTagName("*")).filter((node) => node.localName === "itemref").map((node) => node.getAttribute("idref")?.trim()).filter((value) => Boolean(value));
+    const bookTitle = xmlTextNodes(packageXml, "title")[0] || (input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0);
+    const author = xmlTextNodes(packageXml, "creator")[0];
+    const chapters = [];
+    for (const spineId of spineIds) {
+      const item = manifestEntries.get(spineId);
+      if (!item || !item.mediaType.includes("html") && !item.mediaType.includes("xhtml")) {
+        continue;
+      }
+      if (item.properties.split(/\s+/).includes("nav")) {
+        continue;
+      }
+      const entryPath = resolveZipTarget(packagePath, item.href);
+      const html = zipEntryText(archive, entryPath);
+      if (!html) {
+        continue;
+      }
+      const markdown = htmlToMarkdown(html);
+      if (!markdown) {
+        continue;
+      }
+      const chapterTitle = firstHtmlHeading(html) || markdown.match(/^#\s+(.+)$/m)?.[1]?.trim() || item.href;
+      const normalizedTitle = normalizeWhitespace(chapterTitle);
+      if (!normalizedTitle || /^table of contents$/i.test(normalizedTitle)) {
+        continue;
+      }
+      chapters.push({
+        partKey: item.href,
+        title: normalizedTitle,
+        markdown,
+        metadata: {
+          book_title: bookTitle ?? "",
+          chapter_title: normalizedTitle,
+          author: author ?? ""
+        }
+      });
+    }
+    return {
+      title: bookTitle,
+      author,
+      chapters,
+      warnings: chapters.length ? void 0 : ["EPUB extraction completed but found no chapter-like spine entries."]
+    };
+  } catch (error) {
+    return {
+      chapters: [],
+      warnings: [`EPUB extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+    };
+  }
+}
+function timestampFromMs(value) {
+  const totalMs = Math.max(0, Math.floor(value));
+  const totalSeconds = Math.floor(totalMs / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  const milliseconds = totalMs % 1e3;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(
+    milliseconds
+  ).padStart(3, "0")}`;
+}
+function normalizeDelimitedList(values) {
+  const unique = [...new Set(values.map((value) => normalizeWhitespace(value)).filter(Boolean))];
+  return unique.length ? unique.join(", ") : void 0;
+}
+function normalizeIsoDate(value) {
+  if (value instanceof Date && Number.isFinite(value.getTime())) {
+    return value.toISOString();
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = new Date(value);
+    if (Number.isFinite(parsed.getTime())) {
+      return parsed.toISOString();
+    }
+  }
+  return void 0;
+}
+function addressNames(value) {
+  if (!value || typeof value !== "object" || !("value" in value) || !Array.isArray(value.value)) {
+    return [];
+  }
+  return value.value.map((entry) => normalizeWhitespace(entry.name ?? entry.address ?? "")).filter(Boolean);
+}
+function addressList(value) {
+  return normalizeDelimitedList(addressNames(value));
+}
+function emailConversationId(parsed) {
+  const asArray = (value) => Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  return normalizeWhitespace(parsed.messageId ?? "") || normalizeWhitespace(asArray(parsed.inReplyTo)[0] ?? "") || normalizeWhitespace(asArray(parsed.references)[0] ?? "") || void 0;
+}
+function emailBodyMarkdown(parsed) {
+  const text = normalizeDocumentText(parsed.text ?? "");
+  if (text) {
+    return text;
+  }
+  if (typeof parsed.html === "string" && parsed.html.trim()) {
+    return normalizeDocumentText(htmlToMarkdown(parsed.html));
+  }
+  return "";
+}
+function normalizeParsedEmail(parsed, fallbackTitle) {
+  const title = normalizeWhitespace(parsed.subject ?? "") || fallbackTitle;
+  const sender = addressList(parsed.from);
+  const recipients = addressList(parsed.to);
+  const cc = addressList(parsed.cc);
+  const occurredAt = normalizeIsoDate(parsed.date);
+  const participants = normalizeDelimitedList([...addressNames(parsed.from), ...addressNames(parsed.to), ...addressNames(parsed.cc)]);
+  const conversationId = emailConversationId(parsed);
+  const body = emailBodyMarkdown(parsed);
+  const attachmentCount = Array.isArray(parsed.attachments) ? parsed.attachments.length : 0;
+  return {
+    title,
+    conversationId,
+    metadata: {
+      ...occurredAt ? { occurred_at: occurredAt } : {},
+      ...sender ? { sender } : {},
+      ...recipients ? { recipients } : {},
+      ...cc ? { cc } : {},
+      ...participants ? { participants } : {},
+      ...conversationId ? { conversation_id: conversationId } : {},
+      ...normalizeWhitespace(parsed.messageId ?? "") ? { message_id: normalizeWhitespace(parsed.messageId ?? "") } : {},
+      ...attachmentCount ? { attachment_count: String(attachmentCount) } : {}
+    },
+    markdown: [
+      `# ${title}`,
+      "",
+      ...occurredAt ? [`Date: ${occurredAt}`] : [],
+      ...sender ? [`From: ${sender}`] : [],
+      ...recipients ? [`To: ${recipients}`] : [],
+      ...cc ? [`CC: ${cc}`] : [],
+      ...conversationId ? [`Conversation ID: ${conversationId}`] : [],
+      ...attachmentCount ? [`Attachments: ${attachmentCount}`] : [],
+      "",
+      "## Message",
+      "",
+      body || "No readable body content was extracted from this email.",
+      ""
+    ].join("\n")
+  };
+}
+function calendarAttendees(value) {
+  if (!value) {
+    return [];
+  }
+  const attendees = Array.isArray(value) ? value : [value];
+  return attendees.map((entry) => {
+    if (!entry || typeof entry !== "object") {
+      return "";
+    }
+    const item = entry;
+    const name = normalizeWhitespace(String(item.params?.CN ?? ""));
+    const address = normalizeWhitespace(String(item.val ?? item.value ?? ""));
+    return name || address;
+  }).filter(Boolean);
+}
+function slackFormatSpeakerId(input, usersById) {
+  return usersById.get(input) ?? input;
+}
+function slackNormalizeText(text, usersById) {
+  return normalizeWhitespace(
+    text.replace(/<@([A-Z0-9]+)>/g, (_, userId) => `@${slackFormatSpeakerId(userId, usersById)}`).replace(/<#[A-Z0-9]+\|([^>]+)>/g, "#$1").replace(/<(https?:\/\/[^>|]+)\|([^>]+)>/g, "$2 ($1)").replace(/<(https?:\/\/[^>]+)>/g, "$1")
+  );
+}
+function slackMessageTimestamp(ts2, fallbackDate) {
+  const numeric = Number(ts2);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    return new Date(numeric * 1e3).toISOString();
+  }
+  return (/* @__PURE__ */ new Date(`${fallbackDate}T00:00:00.000Z`)).toISOString();
+}
+async function loadZipMessageBuffers(bytes) {
+  const { MboxStream } = await import("node-mbox");
+  const stream = MboxStream(Readable.from([bytes]));
+  return await new Promise((resolve, reject) => {
+    const messages = [];
+    stream.on("data", (message) => {
+      messages.push(Buffer.isBuffer(message) ? message : Buffer.from(message));
+    });
+    stream.on("error", reject);
+    stream.on("finish", () => resolve(messages));
+    stream.on("end", () => resolve(messages));
+  });
+}
+function archiveEntriesAsText(archive) {
+  return new Map(
+    Object.entries(archive).filter(([, value]) => value).map(([entryPath, value]) => [entryPath, strFromU8(value)])
+  );
+}
+function looksLikeSlackEntries(entries) {
+  const all = [...entries];
+  const hasChannelsIndex = all.some(
+    (entry) => entry === "channels.json" || entry === "groups.json" || entry === "dms.json" || entry === "mpims.json"
+  );
+  const hasChannelDayFiles = all.some((entry) => /^[^/]+\/\d{4}-\d{2}-\d{2}\.json$/i.test(entry));
+  return hasChannelsIndex && hasChannelDayFiles;
+}
+function slackEntriesFromChannelIndex(raw, usersById) {
+  const entries = /* @__PURE__ */ new Map();
+  if (!Array.isArray(raw)) {
+    return entries;
+  }
+  for (const item of raw) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const value = item;
+    const id = normalizeWhitespace(value.id ?? "");
+    const title = normalizeWhitespace(value.name ?? "");
+    if (!title) {
+      continue;
+    }
+    const members = (Array.isArray(value.members) ? value.members : value.user ? [value.user] : []).map((member) => slackFormatSpeakerId(member, usersById)).filter(Boolean);
+    entries.set(title, { id, title, members });
+  }
+  return entries;
+}
+async function extractTranscriptText(input) {
+  try {
+    const { parseSync } = await import("subtitle");
+    const rawText = decodeTextBytes(input.bytes);
+    const cues = parseSync(rawText).filter((node) => node.type === "cue" && node.data).map((node) => ({
+      start: Math.max(0, node.data?.start ?? 0),
+      end: Math.max(0, node.data?.end ?? 0),
+      text: normalizeWhitespace((node.data?.text ?? "").replace(/\s*\n+\s*/g, " "))
+    })).filter((cue) => cue.text);
+    const title = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0;
+    const extractedText = [
+      title ? `# ${title}` : null,
+      `Format: ${input.fileName?.toLowerCase().endsWith(".vtt") ? "WebVTT" : "SRT"}`,
+      `Segments: ${cues.length}`,
+      ...cues.length ? [`Start: ${timestampFromMs(cues[0].start)}`, `End: ${timestampFromMs(cues[cues.length - 1].end)}`] : [],
+      "",
+      "## Transcript",
+      "",
+      ...cues.length ? cues.map((cue) => `- [${timestampFromMs(cue.start)} - ${timestampFromMs(cue.end)}] ${cue.text}`) : ["- No transcript segments were extracted."],
+      ""
+    ].filter((item) => Boolean(item)).join("\n");
+    return {
+      title,
+      extractedText,
+      artifact: {
+        ...extractionMetadata("transcript", input.mimeType, "transcript_text"),
+        metadata: {
+          format: input.fileName?.toLowerCase().endsWith(".vtt") ? "vtt" : "srt",
+          segment_count: String(cues.length),
+          ...cues.length ? { started_at: timestampFromMs(cues[0].start), ended_at: timestampFromMs(cues[cues.length - 1].end) } : {}
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("transcript", input.mimeType, "transcript_text"),
+        warnings: [`Transcript extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractEmailText(input) {
+  try {
+    const { simpleParser } = await import("mailparser");
+    const fallbackTitle = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : "Email";
+    const parsed = await simpleParser(input.bytes);
+    const normalized = normalizeParsedEmail(parsed, fallbackTitle);
+    return {
+      title: normalized.title,
+      extractedText: normalized.markdown,
+      artifact: {
+        ...extractionMetadata("email", input.mimeType, "email_text"),
+        metadata: normalized.metadata
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("email", input.mimeType, "email_text"),
+        warnings: [`Email extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractMboxMessages(input) {
+  try {
+    const title = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : "Mailbox";
+    const { simpleParser } = await import("mailparser");
+    const messages = await loadZipMessageBuffers(input.bytes);
+    const extracted = [];
+    for (let index = 0; index < messages.length; index += 1) {
+      const parsed = await simpleParser(messages[index]);
+      const normalized = normalizeParsedEmail(parsed, `Message ${index + 1}`);
+      const conversationId = normalized.conversationId || `${index + 1}`;
+      extracted.push({
+        partKey: `${conversationId}-${index + 1}`,
+        title: normalized.title,
+        markdown: normalized.markdown,
+        metadata: {
+          ...normalized.metadata,
+          container_title: title,
+          mailbox_title: title,
+          part_index: String(index + 1),
+          part_count: String(messages.length)
+        }
+      });
+    }
+    return {
+      title,
+      messages: extracted,
+      warnings: extracted.length ? void 0 : ["Mailbox extraction completed but found no readable messages."]
+    };
+  } catch (error) {
+    return {
+      messages: [],
+      warnings: [`Mailbox extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+    };
+  }
+}
+async function extractCalendarEvents(input) {
+  try {
+    const ical = await import("node-ical");
+    const calendarTitle = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : "Calendar";
+    const parsed = ical.default.sync.parseICS(decodeTextBytes(input.bytes));
+    const events = [];
+    for (const item of Object.values(parsed)) {
+      if (!item || typeof item !== "object" || item.type !== "VEVENT") {
+        continue;
+      }
+      const event = item;
+      const title = normalizeWhitespace(event.summary ?? "") || "Calendar Event";
+      const occurredAt = normalizeIsoDate(event.start);
+      const endsAt = normalizeIsoDate(event.end);
+      const organizer = event.organizer ? normalizeWhitespace(String(event.organizer.params?.CN ?? event.organizer.val ?? "")) : void 0;
+      const attendees = calendarAttendees(event.attendees);
+      const participants = normalizeDelimitedList([organizer ?? "", ...attendees]);
+      const location = normalizeWhitespace(event.location ?? "") || void 0;
+      const description = normalizeDocumentText(event.description ?? "");
+      const conversationId = normalizeWhitespace(event.uid ?? "") || `${title}-${occurredAt ?? events.length + 1}`;
+      events.push({
+        partKey: conversationId,
+        title,
+        metadata: {
+          container_title: calendarTitle,
+          ...occurredAt ? { occurred_at: occurredAt } : {},
+          ...endsAt ? { ends_at: endsAt } : {},
+          ...organizer ? { organizer } : {},
+          ...location ? { location } : {},
+          ...participants ? { participants } : {},
+          conversation_id: conversationId
+        },
+        markdown: [
+          `# ${title}`,
+          "",
+          ...occurredAt ? [`Start: ${occurredAt}`] : [],
+          ...endsAt ? [`End: ${endsAt}`] : [],
+          ...organizer ? [`Organizer: ${organizer}`] : [],
+          ...attendees.length ? [`Attendees: ${attendees.join(", ")}`] : [],
+          ...location ? [`Location: ${location}`] : [],
+          ...conversationId ? [`Event ID: ${conversationId}`] : [],
+          "",
+          "## Description",
+          "",
+          description || "No event description was provided.",
+          ""
+        ].join("\n")
+      });
+    }
+    return {
+      title: calendarTitle,
+      events,
+      warnings: events.length ? void 0 : ["Calendar extraction completed but found no VEVENT entries."]
+    };
+  } catch (error) {
+    return {
+      events: [],
+      warnings: [`Calendar extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+    };
+  }
+}
+function parseSlackExportEntries(entries, exportTitle) {
+  const usersById = /* @__PURE__ */ new Map();
+  const rawUsers = entries.get("users.json");
+  if (rawUsers) {
+    const parsed = JSON.parse(rawUsers);
+    for (const user of parsed) {
+      const id = normalizeWhitespace(user.id ?? "");
+      const name = normalizeWhitespace(user.profile?.display_name ?? user.real_name ?? user.profile?.real_name ?? user.name ?? "");
+      if (id && name) {
+        usersById.set(id, name);
+      }
+    }
+  }
+  const channelIndex = /* @__PURE__ */ new Map();
+  for (const indexPath of ["channels.json", "groups.json", "dms.json", "mpims.json"]) {
+    const rawIndex = entries.get(indexPath);
+    if (!rawIndex) {
+      continue;
+    }
+    const parsed = JSON.parse(rawIndex);
+    for (const [key, value] of slackEntriesFromChannelIndex(parsed, usersById)) {
+      channelIndex.set(key, value);
+    }
+  }
+  const conversationPaths = [...entries.keys()].filter((entryPath) => /^[^/]+\/\d{4}-\d{2}-\d{2}\.json$/i.test(entryPath)).sort((left, right) => left.localeCompare(right));
+  const conversations = [];
+  for (const entryPath of conversationPaths) {
+    const raw = entries.get(entryPath);
+    if (!raw) {
+      continue;
+    }
+    const messages = JSON.parse(raw);
+    if (!Array.isArray(messages)) {
+      continue;
+    }
+    const [channelName, dateFile] = entryPath.split("/");
+    const date = dateFile?.replace(/\.json$/i, "") ?? "";
+    const channel = channelIndex.get(channelName ?? "") ?? {
+      id: channelName ?? "",
+      title: channelName ?? "channel",
+      members: []
+    };
+    const participants = new Set(channel.members);
+    const lines = [];
+    const threadIds = /* @__PURE__ */ new Set();
+    const sortedMessages = [...messages].sort((left, right) => Number(left.ts ?? 0) - Number(right.ts ?? 0));
+    let occurredAt;
+    for (const message of sortedMessages) {
+      const speaker = normalizeWhitespace(
+        message.username ?? message.bot_profile?.name ?? (message.user ? slackFormatSpeakerId(message.user, usersById) : "")
+      ) || "unknown";
+      participants.add(speaker);
+      const messageTime = slackMessageTimestamp(message.ts, date);
+      occurredAt ??= messageTime;
+      const normalizedText = slackNormalizeText(
+        [
+          message.text ?? "",
+          ...Array.isArray(message.files) ? message.files.map((file) => normalizeWhitespace(file.title ?? file.name ?? "")).filter(Boolean).map((label) => `Attachment: ${label}`) : []
+        ].join("\n"),
+        usersById
+      );
+      if (message.thread_ts && message.thread_ts !== message.ts) {
+        threadIds.add(message.thread_ts);
+      }
+      lines.push(
+        `- [${messageTime}] ${speaker}${message.thread_ts ? ` {thread:${message.thread_ts}}` : ""}${message.ts ? ` {id:${message.ts}}` : ""}: ${normalizedText || normalizeWhitespace(message.subtype ?? "") || "[no text]"}`
+      );
+    }
+    const participantsList = normalizeDelimitedList([...participants]);
+    const conversationId = `${channel.id || channel.title}:${date}`;
+    conversations.push({
+      partKey: `${channel.title}-${date}`,
+      title: `#${channel.title} - ${date}`,
+      metadata: {
+        workspace_title: exportTitle,
+        channel: channel.title,
+        ...channel.id ? { channel_id: channel.id } : {},
+        ...occurredAt ? { occurred_at: occurredAt } : {},
+        ...participantsList ? { participants: participantsList } : {},
+        container_title: `${exportTitle} / #${channel.title}`,
+        conversation_id: conversationId,
+        date,
+        message_count: String(sortedMessages.length),
+        thread_count: String(threadIds.size)
+      },
+      markdown: [
+        `# #${channel.title} - ${date}`,
+        "",
+        `Workspace: ${exportTitle}`,
+        `Messages: ${sortedMessages.length}`,
+        `Threads: ${threadIds.size}`,
+        ...participantsList ? [`Participants: ${participantsList}`] : [],
+        "",
+        "## Messages",
+        "",
+        ...lines.length ? lines : ["- No messages were extracted."],
+        ""
+      ].join("\n")
+    });
+  }
+  return {
+    title: exportTitle,
+    conversations,
+    warnings: conversations.length ? void 0 : ["Slack export parsing completed but found no channel day files."]
+  };
+}
+function isSlackExportArchive(bytes) {
+  try {
+    const archive = unzipSync(new Uint8Array(bytes));
+    return looksLikeSlackEntries(Object.keys(archive));
+  } catch {
+    return false;
+  }
+}
+async function isSlackExportDirectory(directoryPath) {
+  const entries = await fs7.readdir(directoryPath).catch(() => []);
+  if (!entries.length) {
+    return false;
+  }
+  const fileSet = new Set(entries);
+  const hasIndex = ["channels.json", "groups.json", "dms.json", "mpims.json"].some((name) => fileSet.has(name));
+  if (!hasIndex) {
+    return false;
+  }
+  for (const entry of entries) {
+    const channelDir = path7.join(directoryPath, entry);
+    const stat = await fs7.stat(channelDir).catch(() => null);
+    if (!stat?.isDirectory()) {
+      continue;
+    }
+    const channelEntries = await fs7.readdir(channelDir).catch(() => []);
+    if (channelEntries.some((name) => /^\d{4}-\d{2}-\d{2}\.json$/i.test(name))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function extractSlackExportArchive(input) {
+  try {
+    const archive = unzipSync(new Uint8Array(input.bytes));
+    const title = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : "Slack Export";
+    return parseSlackExportEntries(archiveEntriesAsText(archive), title);
+  } catch (error) {
+    return {
+      conversations: [],
+      warnings: [`Slack export extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
     };
   }
 }
-async function extractDocxText(input) {
+async function extractSlackExportDirectory(directoryPath) {
+  const title = path7.basename(directoryPath) || "Slack Export";
   try {
-    const mammoth = await import("mammoth");
-    const result = await mammoth.extractRawText({
-      buffer: input.bytes
-    });
-    const extractedText = normalizeDocumentText(result.value);
-    const warnings = result.messages.map((message) => normalizeWhitespace(message.message)).filter(Boolean).map((message) => truncate(message, 240));
-    const artifact = {
-      ...extractionMetadata("docx", input.mimeType, "docx_text"),
-      metadata: parseDocxCoreMetadata(input.bytes),
-      warnings: warnings.length ? warnings : void 0
-    };
-    if (!extractedText) {
-      artifact.warnings = [...artifact.warnings ?? [], "DOCX text extraction completed but produced no extractable text."];
+    const entries = /* @__PURE__ */ new Map();
+    const queue = [directoryPath];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const children = await fs7.readdir(current, { withFileTypes: true });
+      for (const child of children) {
+        const absoluteChild = path7.join(current, child.name);
+        if (child.isDirectory()) {
+          queue.push(absoluteChild);
+          continue;
+        }
+        const relativeChild = path7.posix.relative(directoryPath, absoluteChild.split(path7.sep).join(path7.posix.sep));
+        entries.set(relativeChild, await fs7.readFile(absoluteChild, "utf8"));
+      }
     }
-    return {
-      extractedText: extractedText || void 0,
-      artifact
-    };
+    return parseSlackExportEntries(entries, title);
   } catch (error) {
     return {
-      artifact: {
-        ...extractionMetadata("docx", input.mimeType, "docx_text"),
-        warnings: [`DOCX text extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
-      }
+      conversations: [],
+      warnings: [`Slack export extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
     };
   }
 }
@@ -5230,21 +6103,42 @@ function inferKind(mimeType, filePath) {
   if (isRstFilePath(filePath)) {
     return "text";
   }
+  if (isTranscriptFilePath(filePath) || mimeType === "application/x-subrip" || mimeType === "text/vtt") {
+    return "transcript";
+  }
   if (mimeType.includes("markdown")) {
     return "markdown";
   }
   if (mimeType.includes("html")) {
     return "html";
   }
-  if (mimeType.startsWith("text/")) {
-    return "text";
-  }
   if (mimeType === "application/pdf" || filePath.toLowerCase().endsWith(".pdf")) {
     return "pdf";
   }
   if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || filePath.toLowerCase().endsWith(".docx")) {
     return "docx";
   }
+  if (isEmailFilePath(filePath) || mimeType === "message/rfc822" || mimeType === "application/mbox") {
+    return "email";
+  }
+  if (isCalendarFilePath(filePath) || mimeType === "text/calendar") {
+    return "calendar";
+  }
+  if (mimeType === "application/epub+zip" || filePath.toLowerCase().endsWith(".epub")) {
+    return "epub";
+  }
+  if (mimeType === "text/csv" || mimeType === "text/tab-separated-values" || filePath.toLowerCase().endsWith(".csv") || filePath.toLowerCase().endsWith(".tsv")) {
+    return "csv";
+  }
+  if (mimeType.startsWith("text/")) {
+    return "text";
+  }
+  if (mimeType === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" || filePath.toLowerCase().endsWith(".xlsx")) {
+    return "xlsx";
+  }
+  if (mimeType === "application/vnd.openxmlformats-officedocument.presentationml.presentation" || filePath.toLowerCase().endsWith(".pptx")) {
+    return "pptx";
+  }
   if (mimeType.startsWith("image/")) {
     return "image";
   }
@@ -5254,6 +6148,17 @@ function isRstFilePath(filePath) {
   const extension = path12.extname(filePath).toLowerCase();
   return extension === ".rst" || extension === ".rest";
 }
+function isTranscriptFilePath(filePath) {
+  const extension = path12.extname(filePath).toLowerCase();
+  return extension === ".srt" || extension === ".vtt";
+}
+function isEmailFilePath(filePath) {
+  const extension = path12.extname(filePath).toLowerCase();
+  return extension === ".eml" || extension === ".mbox";
+}
+function isCalendarFilePath(filePath) {
+  return path12.extname(filePath).toLowerCase() === ".ics";
+}
 function titleFromText(fallback, content, filePath) {
   if (filePath && isRstFilePath(filePath)) {
     const rstTitle = titleFromRst(fallback, content);
@@ -5270,6 +6175,57 @@ function guessMimeType(target) {
   }
   return mime.lookup(target) || "application/octet-stream";
 }
+function sourceGroupIdFor(prepared) {
+  const originKey = prepared.originType === "url" ? prepared.url ?? prepared.title : prepared.originalPath ?? prepared.title;
+  return `${slugify(prepared.title)}-${sha256(originKey).slice(0, 8)}`;
+}
+function groupedPreparedInputsFor(input) {
+  const groupId = sourceGroupIdFor({
+    title: input.title,
+    originType: input.originType,
+    originalPath: input.originalPath,
+    url: input.url
+  });
+  return input.parts.map(
+    (part, index) => finalizePreparedInput({
+      title: `${input.title} - ${part.title}`,
+      originType: input.originType,
+      sourceKind: input.sourceKind,
+      sourceClass: input.sourceClass,
+      originalPath: input.originalPath,
+      repoRelativePath: input.repoRelativePath,
+      url: input.url,
+      mimeType: "text/markdown",
+      storedExtension: input.storedExtension,
+      payloadBytes: Buffer.from(part.markdown, "utf8"),
+      extractedText: part.markdown,
+      extractionArtifact: {
+        extractor: `${input.sourceKind}_text`,
+        sourceKind: input.sourceKind,
+        mimeType: input.mimeType,
+        producedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: {
+          ...part.metadata,
+          part_index: String(index + 1),
+          part_count: String(input.parts.length)
+        },
+        warnings: input.warnings
+      },
+      sourceGroupId: groupId,
+      sourceGroupTitle: input.title,
+      sourcePartKey: part.partKey,
+      partIndex: index + 1,
+      partCount: input.parts.length,
+      partTitle: part.title,
+      details: {
+        ...part.metadata,
+        part_index: String(index + 1),
+        part_count: String(input.parts.length)
+      },
+      logDetails: input.logDetails
+    })
+  );
+}
 function rstAdornmentLine(line) {
   const trimmed = line.trim();
   if (trimmed.length < 3) {
@@ -5500,6 +6456,13 @@ async function findNearestGitRoot2(startPath) {
     current = parent;
   }
 }
+async function detectScopedRepoRoot(rootDir, inputPath, fallbackRoot) {
+  const detectedRepoRoot = await findNearestGitRoot2(inputPath);
+  if (!detectedRepoRoot) {
+    return fallbackRoot;
+  }
+  return withinRoot(rootDir, inputPath) && !withinRoot(rootDir, detectedRepoRoot) ? fallbackRoot : detectedRepoRoot;
+}
 function withinRoot(rootPath, targetPath) {
   const relative = path12.relative(rootPath, targetPath);
   return relative === "" || !relative.startsWith("..") && !path12.isAbsolute(relative);
@@ -5844,6 +6807,9 @@ function manifestMatchesOrigin(manifest, prepared) {
   }
   return Boolean(prepared.originalPath && manifest.originalPath && toPosix(manifest.originalPath) === toPosix(prepared.originalPath));
 }
+function manifestMatchesOriginPart(manifest, prepared) {
+  return manifestMatchesOrigin(manifest, prepared) && (manifest.sourcePartKey ?? "") === (prepared.sourcePartKey ?? "");
+}
 function buildCompositeHash(payloadBytes, attachments = []) {
   if (!attachments.length) {
     return sha256(payloadBytes);
@@ -5941,7 +6907,7 @@ function extractMarkdownImageReferences(content, baseUrl) {
 async function convertHtmlToMarkdown(html, url) {
   const dom = new JSDOM2(html, { url });
   const article = new Readability(dom.window.document).parse();
-  const turndown = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
+  const turndown = new TurndownService2({ headingStyle: "atx", codeBlockStyle: "fenced" });
   const body = article?.content ?? dom.window.document.body.innerHTML;
   const markdown = turndown.turndown(body);
   return {
@@ -5965,21 +6931,26 @@ async function readManifestByHash(manifestsDir, contentHash) {
   }
   return null;
 }
-async function readManifestByOrigin(manifestsDir, prepared) {
+async function readManifestsByOrigin(manifestsDir, prepared) {
   const entries = await fs11.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const manifests = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
     const manifest = await readJsonFile(path12.join(manifestsDir, entry.name));
     if (manifest && manifestMatchesOrigin(manifest, prepared)) {
-      return {
+      manifests.push({
         ...manifest,
         semanticHash: manifest.semanticHash ?? manifest.contentHash
-      };
+      });
     }
   }
-  return null;
+  return manifests;
+}
+async function readManifestByOrigin(manifestsDir, prepared) {
+  const manifests = await readManifestsByOrigin(manifestsDir, prepared);
+  return manifests.find((manifest) => manifestMatchesOriginPart(manifest, prepared)) ?? null;
 }
 async function loadGitignoreMatcher(repoRoot, enabled) {
   if (!enabled) {
@@ -6046,7 +7017,13 @@ async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
         continue;
       }
       const mimeType = guessMimeType(absolutePath);
-      const sourceKind = inferKind(mimeType, absolutePath);
+      let sourceKind = inferKind(mimeType, absolutePath);
+      if (sourceKind === "binary" && path12.extname(absolutePath).toLowerCase() === ".zip") {
+        const bytes = await fs11.readFile(absolutePath);
+        if (isSlackExportArchive(bytes)) {
+          sourceKind = "chat_export";
+        }
+      }
       const sourceClass = sourceClassForRelativePath(relativePath, options);
       if (!supportedDirectoryKind(sourceKind)) {
         skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
@@ -6228,8 +7205,8 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   const semanticHash = prepared.semanticHash ?? contentHash;
   const extractionHash = prepared.extractionHash ?? buildExtractionHash(prepared.extractedText, prepared.extractionArtifact);
   const existingByOrigin = await readManifestByOrigin(paths.manifestsDir, prepared);
-  const existingByHash = existingByOrigin ? null : await readManifestByHash(paths.manifestsDir, contentHash);
-  if (existingByOrigin && existingByOrigin.contentHash === contentHash && existingByOrigin.semanticHash === semanticHash && existingByOrigin.extractionHash === extractionHash && existingByOrigin.title === prepared.title && existingByOrigin.sourceKind === prepared.sourceKind && existingByOrigin.sourceType === prepared.sourceType && existingByOrigin.sourceClass === prepared.sourceClass && existingByOrigin.language === prepared.language && existingByOrigin.mimeType === prepared.mimeType && existingByOrigin.repoRelativePath === prepared.repoRelativePath) {
+  const existingByHash = existingByOrigin || prepared.sourcePartKey ? null : await readManifestByHash(paths.manifestsDir, contentHash);
+  if (existingByOrigin && existingByOrigin.contentHash === contentHash && existingByOrigin.semanticHash === semanticHash && existingByOrigin.extractionHash === extractionHash && existingByOrigin.title === prepared.title && existingByOrigin.sourceKind === prepared.sourceKind && existingByOrigin.sourceType === prepared.sourceType && existingByOrigin.sourceClass === prepared.sourceClass && existingByOrigin.language === prepared.language && existingByOrigin.mimeType === prepared.mimeType && existingByOrigin.repoRelativePath === prepared.repoRelativePath && existingByOrigin.sourceGroupId === prepared.sourceGroupId && existingByOrigin.sourceGroupTitle === prepared.sourceGroupTitle && existingByOrigin.sourcePartKey === prepared.sourcePartKey && existingByOrigin.partIndex === prepared.partIndex && existingByOrigin.partCount === prepared.partCount && existingByOrigin.partTitle === prepared.partTitle && JSON.stringify(existingByOrigin.details ?? {}) === JSON.stringify(prepared.details ?? {})) {
     return { manifest: existingByOrigin, isNew: false, wasUpdated: false };
   }
   if (existingByHash) {
@@ -6288,6 +7265,13 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     mimeType: prepared.mimeType,
     contentHash,
     semanticHash,
+    sourceGroupId: prepared.sourceGroupId,
+    sourceGroupTitle: prepared.sourceGroupTitle,
+    sourcePartKey: prepared.sourcePartKey,
+    partIndex: prepared.partIndex,
+    partCount: prepared.partCount,
+    partTitle: prepared.partTitle,
+    details: prepared.details,
     createdAt: previous?.createdAt ?? now,
     updatedAt: now,
     attachments: manifestAttachments.length ? manifestAttachments : void 0
@@ -6309,6 +7293,42 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   }
   return { manifest, isNew: !previous, wasUpdated: Boolean(previous) };
 }
+async function persistPreparedInputs(rootDir, input, preparedInputs, paths) {
+  const template = preparedInputs[0];
+  const existingByOrigin = template ? await readManifestsByOrigin(paths.manifestsDir, template) : [];
+  const created = [];
+  const updated = [];
+  const unchanged = [];
+  const removed = [];
+  const seenSourceIds = /* @__PURE__ */ new Set();
+  for (const prepared of preparedInputs) {
+    const result = await persistPreparedInput(rootDir, prepared, paths);
+    if (result.isNew) {
+      created.push(result.manifest);
+    } else if (result.wasUpdated) {
+      updated.push(result.manifest);
+    } else {
+      unchanged.push(result.manifest);
+    }
+    seenSourceIds.add(result.manifest.sourceId);
+  }
+  for (const manifest of existingByOrigin) {
+    if (seenSourceIds.has(manifest.sourceId)) {
+      continue;
+    }
+    await removeManifestArtifacts(rootDir, manifest, paths);
+    removed.push(manifest);
+  }
+  return {
+    input,
+    scannedCount: preparedInputs.length,
+    created,
+    updated,
+    unchanged,
+    removed,
+    skipped: []
+  };
+}
 async function removeManifestArtifacts(rootDir, manifest, paths) {
   await fs11.rm(path12.join(paths.manifestsDir, `${manifest.sourceId}.json`), { force: true });
   await fs11.rm(path12.resolve(rootDir, manifest.storedPath), { force: true });
@@ -6335,10 +7355,10 @@ function repoSyncWorkspaceIgnorePaths(rootDir, paths, repoRoot) {
   return candidates.map((candidate) => path12.resolve(candidate)).filter((candidate, index, items) => items.indexOf(candidate) === index).filter((candidate) => withinRoot(repoRoot, candidate));
 }
 function preparedMatchesManifest(manifest, prepared, contentHash) {
-  return manifest.contentHash === contentHash && manifest.extractionHash === (prepared.extractionHash ?? buildExtractionHash(prepared.extractedText, prepared.extractionArtifact)) && manifest.title === prepared.title && manifest.sourceKind === prepared.sourceKind && manifest.sourceType === prepared.sourceType && manifest.sourceClass === prepared.sourceClass && manifest.language === prepared.language && manifest.mimeType === prepared.mimeType && manifest.repoRelativePath === prepared.repoRelativePath;
+  return manifest.contentHash === contentHash && manifest.extractionHash === (prepared.extractionHash ?? buildExtractionHash(prepared.extractedText, prepared.extractionArtifact)) && manifest.semanticHash === (prepared.semanticHash ?? contentHash) && manifest.title === prepared.title && manifest.sourceKind === prepared.sourceKind && manifest.sourceType === prepared.sourceType && manifest.sourceClass === prepared.sourceClass && manifest.language === prepared.language && manifest.mimeType === prepared.mimeType && manifest.repoRelativePath === prepared.repoRelativePath && manifest.sourceGroupId === prepared.sourceGroupId && manifest.sourceGroupTitle === prepared.sourceGroupTitle && manifest.sourcePartKey === prepared.sourcePartKey && manifest.partIndex === prepared.partIndex && manifest.partCount === prepared.partCount && manifest.partTitle === prepared.partTitle && JSON.stringify(manifest.details ?? {}) === JSON.stringify(prepared.details ?? {});
 }
 function shouldDeferWatchSemanticRefresh(sourceKind) {
-  return sourceKind === "markdown" || sourceKind === "text" || sourceKind === "html" || sourceKind === "pdf" || sourceKind === "docx" || sourceKind === "image";
+  return sourceKind === "markdown" || sourceKind === "text" || sourceKind === "html" || sourceKind === "pdf" || sourceKind === "docx" || sourceKind === "epub" || sourceKind === "csv" || sourceKind === "xlsx" || sourceKind === "pptx" || sourceKind === "transcript" || sourceKind === "chat_export" || sourceKind === "email" || sourceKind === "calendar" || sourceKind === "image";
 }
 function pendingSemanticRefreshId(changeType, repoRoot, relativePath) {
   return `pending:${changeType}:${sha256(`${toPosix(repoRoot)}:${relativePath}`).slice(0, 12)}`;
@@ -6404,13 +7424,16 @@ async function syncTrackedRepos(rootDir, options, repoRoots) {
     const currentPaths = new Set(files.map((absolutePath) => path12.resolve(absolutePath)));
     for (const absolutePath of files) {
       const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path12.relative(repoRoot, absolutePath));
-      const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
-      const result = await persistPreparedInput(rootDir, prepared, paths);
-      if (result.isNew) {
-        imported.push(result.manifest);
-      } else if (result.wasUpdated) {
-        updated.push(result.manifest);
-      }
+      const preparedInputs = await prepareFileInputs(
+        rootDir,
+        absolutePath,
+        repoRoot,
+        sourceClassForRelativePath(relativePath, normalizedOptions)
+      );
+      const result = await persistPreparedInputs(rootDir, absolutePath, preparedInputs, paths);
+      imported.push(...result.created);
+      updated.push(...result.updated);
+      removed.push(...result.removed);
       progress.tick();
     }
     progress.finish(`repo=${toPosix(path12.relative(rootDir, repoRoot)) || "."}`);
@@ -6469,9 +7492,6 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
   let scannedCount = 0;
   for (const repoRoot of uniqueRoots) {
     const repoManifests = manifestsByRepoRoot.get(repoRoot) ?? [];
-    const manifestsByOriginalPath = new Map(
-      repoManifests.filter((manifest) => manifest.originalPath).map((manifest) => [path12.resolve(manifest.originalPath), manifest])
-    );
     if (!await fileExists(repoRoot)) {
       for (const manifest of repoManifests) {
         if (shouldDeferWatchSemanticRefresh(manifest.sourceKind)) {
@@ -6507,38 +7527,50 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     const currentPaths = new Set(files.map((absolutePath) => path12.resolve(absolutePath)));
     for (const absolutePath of files) {
       const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path12.relative(repoRoot, absolutePath));
-      const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
-      if (shouldDeferWatchSemanticRefresh(prepared.sourceKind)) {
-        const existing = manifestsByOriginalPath.get(path12.resolve(absolutePath));
-        const contentHash = buildCompositeHash(prepared.payloadBytes, prepared.attachments);
-        const changed = !existing || !preparedMatchesManifest(existing, prepared, contentHash);
+      const preparedInputs = await prepareFileInputs(
+        rootDir,
+        absolutePath,
+        repoRoot,
+        sourceClassForRelativePath(relativePath, normalizedOptions)
+      );
+      const firstPrepared = preparedInputs[0];
+      if (firstPrepared && shouldDeferWatchSemanticRefresh(firstPrepared.sourceKind)) {
+        const existing = repoManifests.filter(
+          (manifest) => manifest.originalPath && path12.resolve(manifest.originalPath) === path12.resolve(absolutePath)
+        );
+        const existingByPartKey = new Map(existing.map((manifest) => [manifest.sourcePartKey ?? "__single__", manifest]));
+        const changed = existing.length !== preparedInputs.length || preparedInputs.some((prepared) => {
+          const match = existingByPartKey.get(prepared.sourcePartKey ?? "__single__");
+          const contentHash = buildCompositeHash(prepared.payloadBytes, prepared.attachments);
+          return !match || !preparedMatchesManifest(match, prepared, contentHash);
+        }) || existing.some(
+          (manifest) => !preparedInputs.some((prepared) => (prepared.sourcePartKey ?? "") === (manifest.sourcePartKey ?? ""))
+        );
         if (changed) {
           pendingSemanticRefresh.push({
             id: pendingSemanticRefreshId(
-              existing ? "modified" : "added",
+              existing.length ? "modified" : "added",
               repoRoot,
-              prepared.repoRelativePath ?? toPosix(path12.relative(repoRoot, absolutePath))
+              firstPrepared.repoRelativePath ?? toPosix(path12.relative(repoRoot, absolutePath))
             ),
             repoRoot,
             path: toPosix(path12.relative(rootDir, absolutePath)),
-            changeType: existing ? "modified" : "added",
+            changeType: existing.length ? "modified" : "added",
             detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            sourceId: existing?.sourceId,
-            sourceKind: prepared.sourceKind
+            sourceId: existing[0]?.sourceId,
+            sourceKind: firstPrepared.sourceKind
           });
-          if (existing?.sourceId) {
-            staleSourceIds.add(existing.sourceId);
+          for (const manifest of existing) {
+            staleSourceIds.add(manifest.sourceId);
           }
         }
         progress.tick();
         continue;
       }
-      const result = await persistPreparedInput(rootDir, prepared, paths);
-      if (result.isNew) {
-        imported.push(result.manifest);
-      } else if (result.wasUpdated) {
-        updated.push(result.manifest);
-      }
+      const result = await persistPreparedInputs(rootDir, absolutePath, preparedInputs, paths);
+      imported.push(...result.created);
+      updated.push(...result.updated);
+      removed.push(...result.removed);
       progress.tick();
     }
     progress.finish(`repo=${toPosix(path12.relative(rootDir, repoRoot)) || "."}`);
@@ -6592,8 +7624,25 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
     staleSourceIds: [...staleSourceIds]
   };
 }
-async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
+async function prepareFileInputs(rootDir, absoluteInput, repoRoot, sourceClass) {
   const payloadBytes = await fs11.readFile(absoluteInput);
+  if (path12.extname(absoluteInput).toLowerCase() === ".zip" && isSlackExportArchive(payloadBytes)) {
+    const slackExport = await extractSlackExportArchive({ mimeType: "application/zip", bytes: payloadBytes, fileName: absoluteInput });
+    if (slackExport.conversations.length) {
+      return groupedPreparedInputsFor({
+        title: slackExport.title?.trim() || path12.basename(absoluteInput, path12.extname(absoluteInput)),
+        originType: "file",
+        sourceKind: "chat_export",
+        sourceClass,
+        originalPath: toPosix(absoluteInput),
+        repoRelativePath: repoRelativePathFor(absoluteInput, repoRoot),
+        mimeType: "application/zip",
+        storedExtension: ".md",
+        warnings: slackExport.warnings,
+        parts: slackExport.conversations
+      });
+    }
+  }
   const mimeType = guessMimeType(absoluteInput);
   const sourceKind = inferKind(mimeType, absoluteInput);
   const language = inferCodeLanguage(absoluteInput, mimeType);
@@ -6623,6 +7672,118 @@ async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
     title = extracted.artifact.metadata?.title?.trim() || title;
     extractedText = extracted.extractedText;
     extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "transcript") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractTranscriptText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "email" && path12.extname(absoluteInput).toLowerCase() === ".eml") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractEmailText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "email" && path12.extname(absoluteInput).toLowerCase() === ".mbox") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractMboxMessages({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    if (extracted.messages.length) {
+      return groupedPreparedInputsFor({
+        title,
+        originType: "file",
+        sourceKind: "email",
+        sourceClass,
+        originalPath: toPosix(absoluteInput),
+        repoRelativePath: repoRelativePathFor(absoluteInput, repoRoot),
+        mimeType,
+        storedExtension: ".md",
+        warnings: extracted.warnings,
+        parts: extracted.messages
+      });
+    }
+    extractionArtifact = {
+      extractor: "email_text",
+      sourceKind: "email",
+      mimeType,
+      producedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      warnings: extracted.warnings ?? ["Mailbox extraction completed but produced no readable messages."]
+    };
+  } else if (sourceKind === "calendar") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractCalendarEvents({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    if (extracted.events.length) {
+      return groupedPreparedInputsFor({
+        title,
+        originType: "file",
+        sourceKind: "calendar",
+        sourceClass,
+        originalPath: toPosix(absoluteInput),
+        repoRelativePath: repoRelativePathFor(absoluteInput, repoRoot),
+        mimeType,
+        storedExtension: ".md",
+        warnings: extracted.warnings,
+        parts: extracted.events
+      });
+    }
+    extractionArtifact = {
+      extractor: "calendar_text",
+      sourceKind: "calendar",
+      mimeType,
+      producedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      warnings: extracted.warnings ?? ["Calendar extraction completed but found no events."]
+    };
+  } else if (sourceKind === "csv") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractCsvText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "xlsx") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractXlsxText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "pptx") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractPptxText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "epub") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractEpubChapters({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    if (extracted.chapters.length) {
+      return groupedPreparedInputsFor({
+        title,
+        originType: "file",
+        sourceKind: "epub",
+        sourceClass,
+        originalPath: toPosix(absoluteInput),
+        repoRelativePath: repoRelativePathFor(absoluteInput, repoRoot),
+        mimeType,
+        storedExtension: ".md",
+        warnings: extracted.warnings,
+        parts: extracted.chapters.map((chapter) => ({
+          ...chapter,
+          metadata: {
+            ...chapter.metadata,
+            ...extracted.author ? { author: extracted.author } : {}
+          }
+        }))
+      });
+    }
+    extractedText = void 0;
+    extractionArtifact = {
+      extractor: "epub_text",
+      sourceKind: "epub",
+      mimeType,
+      producedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      warnings: extracted.warnings ?? ["EPUB extraction completed but produced no chapter content."]
+    };
   } else if (sourceKind === "image") {
     title = path12.basename(absoluteInput, path12.extname(absoluteInput));
     const extracted = await extractImageWithVision(rootDir, {
@@ -6636,23 +7797,33 @@ async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
   } else {
     title = path12.basename(absoluteInput, path12.extname(absoluteInput));
   }
-  return finalizePreparedInput({
-    title,
-    originType: "file",
-    sourceKind,
-    sourceClass,
-    language,
-    originalPath: toPosix(absoluteInput),
-    repoRelativePath: repoRelativePathFor(absoluteInput, repoRoot),
-    mimeType,
-    storedExtension,
-    payloadBytes,
-    extractedText,
-    extractionArtifact,
-    extractionHash: buildExtractionHash(extractedText, extractionArtifact)
-  });
+  return [
+    finalizePreparedInput({
+      title,
+      originType: "file",
+      sourceKind,
+      sourceClass,
+      language,
+      originalPath: toPosix(absoluteInput),
+      repoRelativePath: repoRelativePathFor(absoluteInput, repoRoot),
+      mimeType,
+      storedExtension,
+      payloadBytes,
+      extractedText,
+      extractionArtifact,
+      extractionHash: buildExtractionHash(extractedText, extractionArtifact),
+      details: extractionArtifact?.metadata
+    })
+  ];
 }
-async function prepareUrlInput(rootDir, input, options) {
+async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
+  const prepared = await prepareFileInputs(rootDir, absoluteInput, repoRoot, sourceClass);
+  if (!prepared.length) {
+    throw new Error(`No ingestable sources were extracted from ${absoluteInput}.`);
+  }
+  return prepared[0];
+}
+async function prepareUrlInputs(rootDir, input, options) {
   await validateUrlSafety(input);
   const response = await fetch(input);
   if (!response.ok) {
@@ -6661,6 +7832,25 @@ async function prepareUrlInput(rootDir, input, options) {
   const finalUrl = normalizeOriginUrl(response.url || input);
   const inputUrl = new URL(finalUrl);
   const originalPayloadBytes = Buffer.from(await response.arrayBuffer());
+  if (path12.extname(inputUrl.pathname).toLowerCase() === ".zip" && isSlackExportArchive(originalPayloadBytes)) {
+    const slackExport = await extractSlackExportArchive({
+      mimeType: "application/zip",
+      bytes: originalPayloadBytes,
+      fileName: inputUrl.pathname
+    });
+    if (slackExport.conversations.length) {
+      return groupedPreparedInputsFor({
+        title: slackExport.title?.trim() || inputUrl.hostname,
+        originType: "url",
+        sourceKind: "chat_export",
+        url: finalUrl,
+        mimeType: "application/zip",
+        storedExtension: ".md",
+        warnings: slackExport.warnings,
+        parts: slackExport.conversations
+      });
+    }
+  }
   let payloadBytes = originalPayloadBytes;
   let mimeType = resolveUrlMimeType(input, response);
   let sourceKind = inferKind(mimeType, inputUrl.pathname);
@@ -6747,6 +7937,104 @@ async function prepareUrlInput(rootDir, input, options) {
       title = extracted.artifact.metadata?.title?.trim() || title;
       extractedText = extracted.extractedText;
       extractionArtifact = extracted.artifact;
+    } else if (sourceKind === "transcript") {
+      const extracted = await extractTranscriptText({ mimeType, bytes: payloadBytes, fileName: inputUrl.pathname });
+      title = extracted.title?.trim() || title;
+      extractedText = extracted.extractedText;
+      extractionArtifact = extracted.artifact;
+    } else if (sourceKind === "email" && path12.extname(inputUrl.pathname).toLowerCase() === ".eml") {
+      const extracted = await extractEmailText({ mimeType, bytes: payloadBytes, fileName: inputUrl.pathname });
+      title = extracted.title?.trim() || title;
+      extractedText = extracted.extractedText;
+      extractionArtifact = extracted.artifact;
+    } else if (sourceKind === "email" && path12.extname(inputUrl.pathname).toLowerCase() === ".mbox") {
+      const extracted = await extractMboxMessages({ mimeType, bytes: payloadBytes, fileName: inputUrl.pathname });
+      title = extracted.title?.trim() || title;
+      if (extracted.messages.length) {
+        return groupedPreparedInputsFor({
+          title,
+          originType: "url",
+          sourceKind: "email",
+          url: finalUrl,
+          mimeType,
+          storedExtension: ".md",
+          warnings: extracted.warnings,
+          parts: extracted.messages
+        });
+      }
+      extractionArtifact = {
+        extractor: "email_text",
+        sourceKind: "email",
+        mimeType,
+        producedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        warnings: extracted.warnings ?? ["Mailbox extraction completed but produced no readable messages."]
+      };
+    } else if (sourceKind === "calendar") {
+      const extracted = await extractCalendarEvents({ mimeType, bytes: payloadBytes, fileName: inputUrl.pathname });
+      title = extracted.title?.trim() || title;
+      if (extracted.events.length) {
+        return groupedPreparedInputsFor({
+          title,
+          originType: "url",
+          sourceKind: "calendar",
+          url: finalUrl,
+          mimeType,
+          storedExtension: ".md",
+          warnings: extracted.warnings,
+          parts: extracted.events
+        });
+      }
+      extractionArtifact = {
+        extractor: "calendar_text",
+        sourceKind: "calendar",
+        mimeType,
+        producedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        warnings: extracted.warnings ?? ["Calendar extraction completed but found no events."]
+      };
+    } else if (sourceKind === "csv") {
+      const extracted = await extractCsvText({ mimeType, bytes: payloadBytes, fileName: inputUrl.pathname });
+      title = extracted.title?.trim() || title;
+      extractedText = extracted.extractedText;
+      extractionArtifact = extracted.artifact;
+    } else if (sourceKind === "xlsx") {
+      const extracted = await extractXlsxText({ mimeType, bytes: payloadBytes, fileName: inputUrl.pathname });
+      title = extracted.title?.trim() || title;
+      extractedText = extracted.extractedText;
+      extractionArtifact = extracted.artifact;
+    } else if (sourceKind === "pptx") {
+      const extracted = await extractPptxText({ mimeType, bytes: payloadBytes, fileName: inputUrl.pathname });
+      title = extracted.title?.trim() || title;
+      extractedText = extracted.extractedText;
+      extractionArtifact = extracted.artifact;
+    } else if (sourceKind === "epub") {
+      const extracted = await extractEpubChapters({ mimeType, bytes: payloadBytes, fileName: inputUrl.pathname });
+      title = extracted.title?.trim() || title;
+      if (extracted.chapters.length) {
+        return groupedPreparedInputsFor({
+          title,
+          originType: "url",
+          sourceKind: "epub",
+          url: finalUrl,
+          mimeType,
+          storedExtension: ".md",
+          warnings: extracted.warnings,
+          parts: extracted.chapters.map((chapter) => ({
+            ...chapter,
+            metadata: {
+              ...chapter.metadata,
+              ...extracted.author ? { author: extracted.author } : {}
+            }
+          })),
+          logDetails
+        });
+      }
+      extractionArtifact = {
+        extractor: "epub_text",
+        sourceKind: "epub",
+        mimeType,
+        producedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        warnings: extracted.warnings ?? ["EPUB extraction completed but produced no chapter content."]
+      };
     } else if (sourceKind === "image") {
       const extracted = await extractImageWithVision(rootDir, {
         title,
@@ -6758,22 +8046,32 @@ async function prepareUrlInput(rootDir, input, options) {
       extractionArtifact = extracted.artifact;
     }
   }
-  return finalizePreparedInput({
-    title,
-    originType: "url",
-    sourceKind,
-    language,
-    url: finalUrl,
-    mimeType,
-    storedExtension,
-    payloadBytes,
-    extractedText,
-    extractionArtifact,
-    extractionHash: buildExtractionHash(extractedText, extractionArtifact),
-    attachments,
-    contentHash,
-    logDetails
-  });
+  return [
+    finalizePreparedInput({
+      title,
+      originType: "url",
+      sourceKind,
+      language,
+      url: finalUrl,
+      mimeType,
+      storedExtension,
+      payloadBytes,
+      extractedText,
+      extractionArtifact,
+      extractionHash: buildExtractionHash(extractedText, extractionArtifact),
+      attachments,
+      contentHash,
+      details: extractionArtifact?.metadata,
+      logDetails
+    })
+  ];
+}
+async function prepareUrlInput(rootDir, input, options) {
+  const prepared = await prepareUrlInputs(rootDir, input, options);
+  if (!prepared.length) {
+    throw new Error(`No ingestable sources were extracted from ${input}.`);
+  }
+  return prepared[0];
 }
 async function collectInboxAttachmentRefs(inputDir, files) {
   const refsBySource = /* @__PURE__ */ new Map();
@@ -6905,18 +8203,38 @@ async function prepareInboxHtmlInput(absolutePath, attachmentRefs) {
   };
 }
 function isSupportedInboxKind(sourceKind) {
-  return ["markdown", "text", "html", "pdf", "docx", "image"].includes(sourceKind);
+  return [
+    "markdown",
+    "text",
+    "html",
+    "pdf",
+    "docx",
+    "epub",
+    "csv",
+    "xlsx",
+    "pptx",
+    "transcript",
+    "chat_export",
+    "email",
+    "calendar",
+    "image"
+  ].includes(sourceKind);
 }
 async function ingestInputDetailed(rootDir, input, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = normalizeIngestOptions(options);
   const absoluteInput = path12.resolve(rootDir, input);
-  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot2(absoluteInput).then((value) => value ?? path12.dirname(absoluteInput));
-  const prepared = isHttpUrl(input) ? await prepareUrlInput(rootDir, input, normalizedOptions) : await prepareFileInput(rootDir, absoluteInput, repoRoot);
-  return await persistPreparedInput(rootDir, prepared, paths);
+  const repoRoot = isHttpUrl(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await detectScopedRepoRoot(rootDir, absoluteInput, path12.dirname(absoluteInput));
+  const prepared = isHttpUrl(input) ? await prepareUrlInputs(rootDir, input, normalizedOptions) : await prepareFileInputs(rootDir, absoluteInput, repoRoot);
+  return await persistPreparedInputs(rootDir, input, prepared, paths);
 }
 async function ingestInput(rootDir, input, options) {
-  return (await ingestInputDetailed(rootDir, input, options)).manifest;
+  const result = await ingestInputDetailed(rootDir, input, options);
+  const manifest = [...result.created, ...result.updated, ...result.unchanged][0];
+  if (!manifest) {
+    throw new Error(`No source manifests were created or updated for ${input}.`);
+  }
+  return manifest;
 }
 async function addInput(rootDir, input, options = {}) {
   const { paths } = await initWorkspace(rootDir);
@@ -7004,23 +8322,59 @@ async function ingestDirectory(rootDir, inputDir, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = await resolveRepoIngestOptions(rootDir, options);
   const absoluteInputDir = path12.resolve(rootDir, inputDir);
-  const repoRoot = normalizedOptions.repoRoot ?? await findNearestGitRoot2(absoluteInputDir) ?? absoluteInputDir;
+  const repoRoot = normalizedOptions.repoRoot ?? await detectScopedRepoRoot(rootDir, absoluteInputDir, absoluteInputDir);
   if (!await fileExists(absoluteInputDir)) {
     throw new Error(`Directory not found: ${absoluteInputDir}`);
   }
+  if (await isSlackExportDirectory(absoluteInputDir)) {
+    const extracted = await extractSlackExportDirectory(absoluteInputDir);
+    const preparedInputs = groupedPreparedInputsFor({
+      title: extracted.title?.trim() || path12.basename(absoluteInputDir),
+      originType: "file",
+      sourceKind: "chat_export",
+      originalPath: toPosix(absoluteInputDir),
+      mimeType: "application/json",
+      storedExtension: ".md",
+      warnings: extracted.warnings,
+      parts: extracted.conversations
+    });
+    const result = await persistPreparedInputs(rootDir, absoluteInputDir, preparedInputs, paths);
+    await appendLogEntry(rootDir, "ingest_directory", toPosix(path12.relative(rootDir, absoluteInputDir)) || ".", [
+      `repo_root=${toPosix(path12.relative(rootDir, repoRoot)) || "."}`,
+      `scanned=${preparedInputs.length}`,
+      `imported=${result.created.length}`,
+      `updated=${result.updated.length}`,
+      `skipped=${result.skipped.length}`
+    ]);
+    return {
+      inputDir: absoluteInputDir,
+      repoRoot,
+      scannedCount: preparedInputs.length,
+      imported: result.created,
+      updated: result.updated,
+      skipped: result.skipped
+    };
+  }
   const { files, skipped } = await collectDirectoryFiles(rootDir, absoluteInputDir, repoRoot, normalizedOptions);
   const imported = [];
   const updated = [];
   const progress = createProgressReporter("ingest", files.length);
   for (const absolutePath of files) {
     const relativePath = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path12.relative(repoRoot, absolutePath));
-    const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot, sourceClassForRelativePath(relativePath, normalizedOptions));
-    const result = await persistPreparedInput(rootDir, prepared, paths);
-    if (result.isNew) {
-      imported.push(result.manifest);
-    } else if (result.wasUpdated) {
-      updated.push(result.manifest);
-    } else {
+    const preparedInputs = await prepareFileInputs(
+      rootDir,
+      absolutePath,
+      repoRoot,
+      sourceClassForRelativePath(relativePath, normalizedOptions)
+    );
+    const result = await persistPreparedInputs(rootDir, absolutePath, preparedInputs, paths);
+    if (result.created.length) {
+      imported.push(...result.created);
+    }
+    if (result.updated.length) {
+      updated.push(...result.updated);
+    }
+    if (!result.created.length && !result.updated.length && !result.removed.length) {
       skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: "duplicate_content" });
     }
     progress.tick();
@@ -7065,19 +8419,25 @@ async function importInbox(rootDir, inputDir) {
       continue;
     }
     const mimeType = guessMimeType(absolutePath);
-    const sourceKind = inferKind(mimeType, absolutePath);
+    let sourceKind = inferKind(mimeType, absolutePath);
+    if (sourceKind === "binary" && path12.extname(absolutePath).toLowerCase() === ".zip") {
+      const bytes = await fs11.readFile(absolutePath);
+      if (isSlackExportArchive(bytes)) {
+        sourceKind = "chat_export";
+      }
+    }
     if (!isSupportedInboxKind(sourceKind)) {
       skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
       continue;
     }
     const prepared = sourceKind === "markdown" && refsBySource.has(absolutePath) ? await prepareInboxMarkdownInput(absolutePath, refsBySource.get(absolutePath) ?? []) : sourceKind === "html" && refsBySource.has(absolutePath) ? await prepareInboxHtmlInput(absolutePath, refsBySource.get(absolutePath) ?? []) : await prepareFileInput(rootDir, absolutePath);
-    const result = await persistPreparedInput(rootDir, prepared, paths);
-    if (!result.isNew) {
+    const result = await persistPreparedInputs(rootDir, absolutePath, [prepared], paths);
+    if (!result.created.length) {
       skipped.push({ path: toPosix(path12.relative(rootDir, absolutePath)), reason: "duplicate_content" });
       continue;
     }
-    attachmentCount += result.manifest.attachments?.length ?? 0;
-    imported.push(result.manifest);
+    attachmentCount += result.created.reduce((total, manifest) => total + (manifest.attachments?.length ?? 0), 0);
+    imported.push(...result.created);
   }
   await appendLogEntry(rootDir, "inbox_import", toPosix(path12.relative(rootDir, effectiveInputDir)) || ".", [
     `scanned=${files.length}`,
@@ -9292,7 +10652,20 @@ function relatedOutputsSection(relatedOutputs) {
   if (!relatedOutputs.length) {
     return [];
   }
-  return ["## Related Outputs", "", ...relatedOutputs.map((page) => `- ${pageLink(page)}`), ""];
+  return ["## Related Outputs", "", ...relatedOutputs.map((page) => `- ${pageLink(page)}`), ""];
+}
+function detailValue(manifest, key) {
+  const value = manifest.details?.[key];
+  const normalized = typeof value === "string" ? value.trim() : "";
+  return normalized || void 0;
+}
+function detailList(manifest, key) {
+  const value = detailValue(manifest, key);
+  if (!value) {
+    return void 0;
+  }
+  const items = value.split(",").map((item) => item.trim()).filter(Boolean);
+  return items.length ? items : void 0;
 }
 function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutputs = [], modulePage, decorations) {
   const relativePath = pagePathFor("source", manifest.sourceId);
@@ -9317,6 +10690,10 @@ function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutput
     title: analysis.title,
     ...manifest.sourceType ? { source_type: manifest.sourceType } : {},
     ...manifest.sourceClass ? { source_class: manifest.sourceClass } : {},
+    ...detailValue(manifest, "occurred_at") ? { occurred_at: detailValue(manifest, "occurred_at") } : {},
+    ...detailList(manifest, "participants") ? { participants: detailList(manifest, "participants") } : {},
+    ...detailValue(manifest, "container_title") ? { container_title: detailValue(manifest, "container_title") } : {},
+    ...detailValue(manifest, "conversation_id") ? { conversation_id: detailValue(manifest, "conversation_id") } : {},
     tags: decoratedTags(analysis.code ? ["source", "code"] : ["source"], decorations),
     source_ids: [manifest.sourceId],
     project_ids: decorations?.projectIds ?? [],
@@ -9336,9 +10713,19 @@ function buildSourcePage(manifest, analysis, schemaHash, metadata, relatedOutput
     `# ${analysis.title}`,
     "",
     `Source ID: \`${manifest.sourceId}\``,
+    `Source Kind: \`${manifest.sourceKind}\``,
     manifest.url ? `Source URL: ${manifest.url}` : `Source Path: \`${manifest.originalPath ?? manifest.storedPath}\``,
     ...manifest.sourceType ? [`Source Type: \`${manifest.sourceType}\``, ""] : [""],
     ...manifest.sourceClass ? [`Source Class: \`${manifest.sourceClass}\``, ""] : [],
+    ...manifest.sourceGroupTitle ? [`Source Group: ${manifest.sourceGroupTitle}`] : [],
+    ...manifest.partTitle ? [`Part: ${manifest.partIndex ?? "?"}/${manifest.partCount ?? "?"} - ${manifest.partTitle}`] : [],
+    ...manifest.details && Object.keys(manifest.details).length ? [
+      "",
+      "## Source Details",
+      "",
+      ...Object.entries(manifest.details).map(([key, value]) => `- ${key.replace(/_/g, " ")}: ${value}`),
+      ""
+    ] : [],
     "",
     "## Summary",
     "",
@@ -9639,6 +11026,9 @@ function buildIndexPage(pages, schemaHash, metadata, projectPages = []) {
   const outputs = pages.filter((page) => page.kind === "output");
   const insights = pages.filter((page) => page.kind === "insight");
   const graphPages = pages.filter((page) => page.kind === "graph_report" || page.kind === "community_summary");
+  const dashboards = pages.filter(
+    (page) => page.kind === "index" && page.path.startsWith("dashboards/") && page.path !== "dashboards/index.md"
+  );
   return [
     "---",
     "page_id: index",
@@ -9684,6 +11074,10 @@ function buildIndexPage(pages, schemaHash, metadata, projectPages = []) {
     "",
     ...outputs.length ? outputs.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No saved outputs yet."],
     "",
+    "## Dashboards",
+    "",
+    ...dashboards.length ? dashboards.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No dashboards yet."],
+    "",
     "## Graph",
     "",
     ...graphPages.length ? graphPages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No graph reports yet."],
@@ -11160,15 +12554,37 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
   const insertPage = db.prepare(
     "INSERT INTO pages (id, path, title, body, kind, status, source_type, source_class, project_ids, project_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
   );
+  const rootDir = path21.dirname(wikiDir);
   for (const page of pages) {
     const absolutePath = path21.join(wikiDir, page.path);
     const content = await fs17.readFile(absolutePath, "utf8");
     const parsed = matter8(content);
+    let body = parsed.content;
+    const primarySourceId = Array.isArray(parsed.data.source_ids) && typeof parsed.data.source_ids[0] === "string" ? parsed.data.source_ids[0] : page.sourceIds[0];
+    if ((page.kind === "source" || page.kind === "module") && primarySourceId) {
+      try {
+        const manifest = JSON.parse(
+          await fs17.readFile(path21.join(rootDir, "state", "manifests", `${primarySourceId}.json`), "utf8")
+        );
+        const excerptPath = manifest.extractedTextPath ?? manifest.storedPath;
+        if (excerptPath) {
+          const excerpt = await fs17.readFile(path21.join(rootDir, excerptPath), "utf8");
+          if (excerpt.trim()) {
+            body = `${body}
+
+## Source Excerpt
+
+${excerpt.trim()}`.trim();
+          }
+        }
+      } catch {
+      }
+    }
     insertPage.run(
       page.id,
       page.path,
       page.title,
-      parsed.content,
+      body,
       page.kind,
       page.status,
       typeof parsed.data.source_type === "string" ? parsed.data.source_type : "",
@@ -11229,7 +12645,25 @@ function searchPages(dbPath, query, limitOrOptions = 5) {
     FROM page_search
     JOIN pages ON pages.rowid = page_search.rowid
     WHERE ${clauses.join(" AND ")}
-    ORDER BY rank
+    ORDER BY
+      CASE pages.status
+        WHEN 'active' THEN 0
+        WHEN 'draft' THEN 1
+        WHEN 'candidate' THEN 2
+        ELSE 3
+      END,
+      CASE pages.kind
+        WHEN 'source' THEN 0
+        WHEN 'module' THEN 1
+        WHEN 'output' THEN 2
+        WHEN 'insight' THEN 3
+        WHEN 'graph_report' THEN 4
+        WHEN 'community_summary' THEN 5
+        WHEN 'concept' THEN 6
+        WHEN 'entity' THEN 7
+        ELSE 8
+      END,
+      rank
     LIMIT ?
   `);
   params.push(options.limit ?? 5);
@@ -11926,6 +13360,267 @@ async function buildManagedContent(absolutePath, defaults, build) {
   }
   return content;
 }
+function manifestDetailValue(manifest, key) {
+  const value = manifest.details?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+async function loadAnalysesBySourceIds(paths, sourceIds) {
+  const analyses = await Promise.all(
+    sourceIds.map(async (sourceId) => await readJsonFile(path22.join(paths.analysesDir, `${sourceId}.json`)))
+  );
+  return analyses.filter((analysis) => Boolean(analysis?.sourceId));
+}
+async function buildDashboardRecords(paths, graph, schemaHash, report) {
+  const sourcePages = graph.pages.filter((page) => page.kind === "source");
+  const reviewPages = graph.pages.filter((page) => page.kind === "output" && page.path.startsWith("outputs/source-reviews/"));
+  const briefPages = graph.pages.filter((page) => page.kind === "output" && page.path.startsWith("outputs/source-briefs/"));
+  const manifests = graph.sources;
+  const manifestBySourceId = new Map(manifests.map((manifest) => [manifest.sourceId, manifest]));
+  const timelineManifests = manifests.filter((manifest) => manifestDetailValue(manifest, "occurred_at")).sort((left, right) => (manifestDetailValue(right, "occurred_at") ?? "").localeCompare(manifestDetailValue(left, "occurred_at") ?? "")).slice(0, 25);
+  const recentSourcePages = [...sourcePages].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).slice(0, 20);
+  const analyses = await loadAnalysesBySourceIds(paths, uniqueStrings3(sourcePages.flatMap((page) => page.sourceIds)));
+  const openQuestions = uniqueStrings3(
+    analyses.flatMap((analysis) => analysis.questions.map((question) => `${analysis.title}: ${question}`))
+  ).slice(0, 20);
+  const dashboards = [
+    {
+      relativePath: "dashboards/index.md",
+      title: "Dashboards",
+      content: (metadata) => matter9.stringify(
+        [
+          "# Dashboards",
+          "",
+          "- [[dashboards/recent-sources|Recent Sources]]",
+          "- [[dashboards/timeline|Timeline]]",
+          "- [[dashboards/contradictions|Contradictions]]",
+          "- [[dashboards/open-questions|Open Questions]]",
+          "",
+          "```dataview",
+          "TABLE file.mtime AS updated",
+          'FROM "dashboards"',
+          'WHERE file.name != "index"',
+          "SORT file.mtime desc",
+          "```",
+          ""
+        ].join("\n"),
+        {
+          page_id: "dashboards:index",
+          kind: "index",
+          title: "Dashboards",
+          tags: ["index", "dashboards"],
+          source_ids: [],
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: metadata.status,
+          confidence: 1,
+          created_at: metadata.createdAt,
+          updated_at: metadata.updatedAt,
+          compiled_from: metadata.compiledFrom,
+          managed_by: metadata.managedBy,
+          backlinks: [],
+          schema_hash: schemaHash,
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      )
+    },
+    {
+      relativePath: "dashboards/recent-sources.md",
+      title: "Recent Sources",
+      content: (metadata) => matter9.stringify(
+        [
+          "# Recent Sources",
+          "",
+          ...recentSourcePages.length ? recentSourcePages.map((page) => `- ${page.updatedAt}: [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No source pages yet."],
+          "",
+          "```dataview",
+          "TABLE source_type, occurred_at, participants",
+          'FROM "sources"',
+          "SORT updated_at desc",
+          "LIMIT 25",
+          "```",
+          ""
+        ].join("\n"),
+        {
+          page_id: "dashboards:recent-sources",
+          kind: "index",
+          title: "Recent Sources",
+          tags: ["index", "dashboard", "recent-sources"],
+          source_ids: recentSourcePages.flatMap((page) => page.sourceIds),
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: metadata.status,
+          confidence: 1,
+          created_at: metadata.createdAt,
+          updated_at: metadata.updatedAt,
+          compiled_from: recentSourcePages.flatMap((page) => page.sourceIds),
+          managed_by: metadata.managedBy,
+          backlinks: [],
+          schema_hash: schemaHash,
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      )
+    },
+    {
+      relativePath: "dashboards/timeline.md",
+      title: "Timeline",
+      content: (metadata) => matter9.stringify(
+        [
+          "# Timeline",
+          "",
+          ...timelineManifests.length ? timelineManifests.map((manifest) => {
+            const occurredAt = manifestDetailValue(manifest, "occurred_at") ?? manifest.updatedAt;
+            const sourcePage = sourcePages.find((page) => page.sourceIds.includes(manifest.sourceId));
+            return `- ${occurredAt}: ${sourcePage ? `[[${sourcePage.path.replace(/\.md$/, "")}|${sourcePage.title}]]` : manifest.title}`;
+          }) : ["- No timeline-aware sources yet."],
+          "",
+          "```dataview",
+          "TABLE occurred_at, participants, container_title",
+          'FROM "sources"',
+          "WHERE occurred_at",
+          "SORT occurred_at desc",
+          "```",
+          ""
+        ].join("\n"),
+        {
+          page_id: "dashboards:timeline",
+          kind: "index",
+          title: "Timeline",
+          tags: ["index", "dashboard", "timeline"],
+          source_ids: timelineManifests.map((manifest) => manifest.sourceId),
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: metadata.status,
+          confidence: 1,
+          created_at: metadata.createdAt,
+          updated_at: metadata.updatedAt,
+          compiled_from: timelineManifests.map((manifest) => manifest.sourceId),
+          managed_by: metadata.managedBy,
+          backlinks: [],
+          schema_hash: schemaHash,
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      )
+    },
+    {
+      relativePath: "dashboards/contradictions.md",
+      title: "Contradictions",
+      content: (metadata) => matter9.stringify(
+        [
+          "# Contradictions",
+          "",
+          ...report?.contradictions.length ? report.contradictions.map((contradiction) => {
+            const left = manifestBySourceId.get(contradiction.sourceIdA)?.title ?? contradiction.sourceIdA;
+            const right = manifestBySourceId.get(contradiction.sourceIdB)?.title ?? contradiction.sourceIdB;
+            return `- ${left} / ${right}: ${contradiction.claimA} <> ${contradiction.claimB}`;
+          }) : ["- No contradictions are currently flagged."],
+          "",
+          ...reviewPages.length || briefPages.length ? [
+            "## Related Reviews",
+            "",
+            ...[...reviewPages, ...briefPages].slice(0, 12).map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`),
+            ""
+          ] : [],
+          "```dataview",
+          'LIST FROM "outputs/source-reviews"',
+          "SORT file.mtime desc",
+          "```",
+          ""
+        ].join("\n"),
+        {
+          page_id: "dashboards:contradictions",
+          kind: "index",
+          title: "Contradictions",
+          tags: ["index", "dashboard", "contradictions"],
+          source_ids: report?.contradictions.flatMap((item) => [item.sourceIdA, item.sourceIdB]) ?? [],
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: metadata.status,
+          confidence: 1,
+          created_at: metadata.createdAt,
+          updated_at: metadata.updatedAt,
+          compiled_from: report?.contradictions.flatMap((item) => [item.sourceIdA, item.sourceIdB]) ?? [],
+          managed_by: metadata.managedBy,
+          backlinks: [],
+          schema_hash: schemaHash,
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      )
+    },
+    {
+      relativePath: "dashboards/open-questions.md",
+      title: "Open Questions",
+      content: (metadata) => matter9.stringify(
+        [
+          "# Open Questions",
+          "",
+          ...openQuestions.length ? openQuestions.map((question) => `- ${question}`) : ["- No open questions are currently extracted."],
+          "",
+          "```dataview",
+          'LIST FROM "outputs/source-briefs" OR "outputs/source-reviews"',
+          "SORT file.mtime desc",
+          "```",
+          ""
+        ].join("\n"),
+        {
+          page_id: "dashboards:open-questions",
+          kind: "index",
+          title: "Open Questions",
+          tags: ["index", "dashboard", "open-questions"],
+          source_ids: analyses.map((analysis) => analysis.sourceId),
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: metadata.status,
+          confidence: 1,
+          created_at: metadata.createdAt,
+          updated_at: metadata.updatedAt,
+          compiled_from: analyses.map((analysis) => analysis.sourceId),
+          managed_by: metadata.managedBy,
+          backlinks: [],
+          schema_hash: schemaHash,
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      )
+    }
+  ];
+  const records = [];
+  for (const dashboard of dashboards) {
+    const absolutePath = path22.join(paths.wikiDir, dashboard.relativePath);
+    const compiledFrom = dashboard.relativePath === "dashboards/recent-sources.md" ? recentSourcePages.flatMap((page) => page.sourceIds) : [];
+    const content = await buildManagedContent(
+      absolutePath,
+      {
+        managedBy: "system",
+        compiledFrom
+      },
+      dashboard.content
+    );
+    records.push({
+      page: emptyGraphPage({
+        id: `dashboard:${dashboard.relativePath.replace(/\.md$/, "")}`,
+        path: dashboard.relativePath,
+        title: dashboard.title,
+        kind: "index",
+        sourceIds: compiledFrom,
+        nodeIds: [],
+        schemaHash,
+        sourceHashes: {},
+        confidence: 1
+      }),
+      content
+    });
+  }
+  return records;
+}
 function indexCompiledFrom(pages) {
   return uniqueStrings3(pages.flatMap((page) => page.sourceIds));
 }
@@ -12951,8 +14646,19 @@ async function syncVaultArtifacts(rootDir, input) {
     input.previousState?.generatedAt,
     contradictions
   );
-  records.push(...graphOrientation.records);
-  const allPages = [...basePages, ...graphOrientation.records.map((record) => record.page)];
+  const preliminaryPages = [...basePages, ...graphOrientation.records.map((record) => record.page)];
+  const dashboardRecords = await buildDashboardRecords(
+    paths,
+    {
+      ...baseGraph,
+      sources: input.manifests,
+      pages: preliminaryPages
+    },
+    globalSchemaHash,
+    graphOrientation.report
+  );
+  records.push(...graphOrientation.records, ...dashboardRecords);
+  const allPages = uniqueBy([...preliminaryPages, ...dashboardRecords.map((record) => record.page)], (page) => page.id);
   const graph = {
     ...baseGraph,
     pages: allPages
@@ -13056,6 +14762,11 @@ async function syncVaultArtifacts(rootDir, input) {
     ["concepts/index.md", "concepts", activeConceptPages],
     ["entities/index.md", "entities", activeEntityPages],
     ["outputs/index.md", "outputs", allPages.filter((page) => page.kind === "output")],
+    [
+      "dashboards/index.md",
+      "dashboards",
+      allPages.filter((page) => page.kind === "index" && page.path.startsWith("dashboards/") && page.path !== "dashboards/index.md")
+    ],
     ["candidates/index.md", "candidates", candidatePages],
     ["graph/index.md", "graph", allPages.filter((page) => page.kind === "graph_report" || page.kind === "community_summary")]
   ]) {
@@ -13156,17 +14867,40 @@ async function refreshIndexesAndSearch(rootDir, pages) {
   const compileState = await readJsonFile(paths.compileStatePath);
   const globalSchemaHash = schemas.effective.global.hash;
   const currentGraph = await readJsonFile(paths.graphPath);
-  const basePages = pages.filter((page) => page.kind !== "graph_report" && page.kind !== "community_summary");
+  const orientationPages = uniqueBy(
+    pages.filter((page) => page.kind !== "graph_report" && page.kind !== "community_summary"),
+    (page) => page.id
+  );
+  const basePages = uniqueBy(
+    pages.filter(
+      (page) => page.kind !== "graph_report" && page.kind !== "community_summary" && !(page.kind === "index" && page.path.startsWith("dashboards/"))
+    ),
+    (page) => page.id
+  );
   const graphOrientation = currentGraph ? await buildGraphOrientationPages(
     {
       ...currentGraph,
-      pages: basePages
+      pages: orientationPages
     },
     paths,
     globalSchemaHash,
     compileState?.generatedAt
   ) : { records: [], report: null };
-  const pagesWithGraph = sortGraphPages([...basePages, ...graphOrientation.records.map((record) => record.page)]);
+  const dashboardRecords = currentGraph ? await buildDashboardRecords(
+    paths,
+    {
+      ...currentGraph,
+      pages: [...basePages, ...graphOrientation.records.map((record) => record.page)]
+    },
+    globalSchemaHash,
+    graphOrientation.report
+  ) : [];
+  const pagesWithGraph = sortGraphPages(
+    uniqueBy(
+      [...basePages, ...graphOrientation.records.map((record) => record.page), ...dashboardRecords.map((record) => record.page)],
+      (page) => page.id
+    )
+  );
   if (currentGraph) {
     await writeJsonFile(paths.graphPath, {
       ...currentGraph,
@@ -13194,6 +14928,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     ensureDir(path22.join(paths.wikiDir, "concepts")),
     ensureDir(path22.join(paths.wikiDir, "entities")),
     ensureDir(path22.join(paths.wikiDir, "outputs")),
+    ensureDir(path22.join(paths.wikiDir, "dashboards")),
     ensureDir(path22.join(paths.wikiDir, "graph")),
     ensureDir(path22.join(paths.wikiDir, "graph", "communities")),
     ensureDir(path22.join(paths.wikiDir, "projects")),
@@ -13256,6 +14991,11 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     ["concepts/index.md", "concepts", pagesWithGraph.filter((page) => page.kind === "concept" && page.status !== "candidate")],
     ["entities/index.md", "entities", pagesWithGraph.filter((page) => page.kind === "entity" && page.status !== "candidate")],
     ["outputs/index.md", "outputs", pagesWithGraph.filter((page) => page.kind === "output")],
+    [
+      "dashboards/index.md",
+      "dashboards",
+      pagesWithGraph.filter((page) => page.kind === "index" && page.path.startsWith("dashboards/") && page.path !== "dashboards/index.md")
+    ],
     ["candidates/index.md", "candidates", pagesWithGraph.filter((page) => page.status === "candidate")],
     ["graph/index.md", "graph", pagesWithGraph.filter((page) => page.kind === "graph_report" || page.kind === "community_summary")]
   ]) {
@@ -13275,6 +15015,9 @@ async function refreshIndexesAndSearch(rootDir, pages) {
   for (const record of graphOrientation.records) {
     await writeFileIfChanged(path22.join(paths.wikiDir, record.page.path), record.content);
   }
+  for (const record of dashboardRecords) {
+    await writeFileIfChanged(path22.join(paths.wikiDir, record.page.path), record.content);
+  }
   if (graphOrientation.report) {
     await writeJsonFile(path22.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   }
@@ -13291,6 +15034,11 @@ async function refreshIndexesAndSearch(rootDir, pages) {
   await Promise.all(
     existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs18.rm(path22.join(paths.wikiDir, relativePath), { force: true }))
   );
+  const existingDashboardPages = (await listFilesRecursive(path22.join(paths.wikiDir, "dashboards")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path22.relative(paths.wikiDir, absolutePath)));
+  const allowedDashboardPages = /* @__PURE__ */ new Set(["dashboards/index.md", ...dashboardRecords.map((record) => record.page.path)]);
+  await Promise.all(
+    existingDashboardPages.filter((relativePath) => !allowedDashboardPages.has(relativePath)).map((relativePath) => fs18.rm(path22.join(paths.wikiDir, relativePath), { force: true }))
+  );
   await rebuildSearchIndex(paths.searchDbPath, pagesWithGraph, paths.wikiDir);
 }
 async function prepareOutputPageSave(rootDir, input) {
@@ -13426,6 +15174,9 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
   });
   return { approvalId, approvalDir };
 }
+async function stageGeneratedOutputPages(rootDir, stagedPages) {
+  return await stageOutputApprovalBundle(rootDir, stagedPages);
+}
 async function executeQuery(rootDir, question, format) {
   const { paths } = await loadVaultConfig(rootDir);
   const schemas = await loadVaultSchemas(rootDir);
@@ -14767,7 +16518,17 @@ async function benchmarkVault(rootDir, options = {}) {
   });
   await writeJsonFile(paths.benchmarkPath, artifact);
   await refreshIndexesAndSearch(rootDir, graph.pages);
-  return artifact;
+  const refreshedGraph = await readJsonFile(paths.graphPath) ?? graph;
+  const refreshedHash = graphHash(refreshedGraph);
+  if (artifact.graphHash === refreshedHash) {
+    return artifact;
+  }
+  const refreshedArtifact = {
+    ...artifact,
+    graphHash: refreshedHash
+  };
+  await writeJsonFile(paths.benchmarkPath, refreshedArtifact);
+  return refreshedArtifact;
 }
 async function pathGraphVault(rootDir, from, to) {
   const graph = await ensureCompiledGraph(rootDir);
@@ -14987,7 +16748,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.2.2";
+var SERVER_VERSION = "0.4.0";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -15165,8 +16926,8 @@ async function createMcpServer(rootDir) {
       }
     },
     async ({ input }) => {
-      const manifest = await ingestInput(rootDir, input);
-      return asToolText(manifest);
+      const result = await ingestInputDetailed(rootDir, input);
+      return asToolText(result);
     }
   );
   server.registerTool(
@@ -15843,7 +17604,7 @@ function matchesManagedSourceSpec(existing, input) {
   if (existing.kind !== input.kind) {
     return false;
   }
-  if (input.kind === "directory") {
+  if (input.kind === "directory" || input.kind === "file") {
     return path25.resolve(existing.path ?? "") === path25.resolve(input.path);
   }
   return (existing.url ?? "") === input.url;
@@ -15855,10 +17616,15 @@ async function resolveManagedSourceInput(rootDir, input) {
     if (!stat) {
       throw new Error(`Source not found: ${input}`);
     }
+    if (stat.isFile()) {
+      return {
+        kind: "file",
+        path: absoluteInput,
+        title: path25.basename(absoluteInput, path25.extname(absoluteInput)) || absoluteInput
+      };
+    }
     if (!stat.isDirectory()) {
-      throw new Error(
-        "`swarmvault source add` supports directories, public GitHub repo root URLs, and docs hubs. Use `swarmvault ingest` for single files."
-      );
+      throw new Error("`swarmvault source add` supports local files, directories, public GitHub repo root URLs, and docs hubs.");
     }
     const detectedRepoRoot = await findNearestGitRoot3(absoluteInput);
     const repoRoot = detectedRepoRoot && !(withinRoot2(rootDir, absoluteInput) && !withinRoot2(rootDir, detectedRepoRoot)) ? detectedRepoRoot : absoluteInput;
@@ -15891,6 +17657,10 @@ async function resolveManagedSourceInput(rootDir, input) {
 function directorySourceIdsFor(manifests, inputPath) {
   return manifests.filter((manifest) => manifest.originalPath && withinRoot2(path25.resolve(inputPath), path25.resolve(manifest.originalPath))).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
 }
+function fileSourceIdsFor(manifests, inputPath) {
+  const absoluteInput = path25.resolve(inputPath);
+  return manifests.filter((manifest) => manifest.originalPath && path25.resolve(manifest.originalPath) === absoluteInput).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
+}
 async function syncDirectorySource(rootDir, inputPath, repoRoot) {
   const manifestsBefore = await listManifests(rootDir);
   const previousInScope = manifestsBefore.filter(
@@ -15924,6 +17694,22 @@ async function syncDirectorySource(rootDir, inputPath, repoRoot) {
     changed: result.imported.length + result.updated.length + removed.length > 0
   };
 }
+async function syncFileSource(rootDir, inputPath) {
+  const result = await ingestInputDetailed(rootDir, inputPath);
+  const manifestsAfter = await listManifests(rootDir);
+  return {
+    title: path25.basename(inputPath, path25.extname(inputPath)) || inputPath,
+    sourceIds: fileSourceIdsFor(manifestsAfter, inputPath),
+    counts: {
+      scannedCount: result.scannedCount,
+      importedCount: result.created.length,
+      updatedCount: result.updated.length,
+      removedCount: result.removed.length,
+      skippedCount: result.skipped.length
+    },
+    changed: result.created.length + result.updated.length + result.removed.length > 0
+  };
+}
 async function runGitCommand(cwd, args) {
   await new Promise((resolve, reject) => {
     const child = spawn2("git", args, {
@@ -15970,12 +17756,11 @@ async function syncCrawlSource(rootDir, entry, options) {
   let updatedCount = 0;
   for (const pageUrl of crawl.pages) {
     const persisted = await ingestInputDetailed(rootDir, pageUrl);
-    currentSourceIds.push(persisted.manifest.sourceId);
-    if (persisted.isNew) {
-      importedCount += 1;
-    } else if (persisted.wasUpdated) {
-      updatedCount += 1;
-    }
+    currentSourceIds.push(...persisted.created.map((manifest) => manifest.sourceId));
+    currentSourceIds.push(...persisted.updated.map((manifest) => manifest.sourceId));
+    currentSourceIds.push(...persisted.unchanged.map((manifest) => manifest.sourceId));
+    importedCount += persisted.created.length;
+    updatedCount += persisted.updated.length;
   }
   let removedCount = 0;
   for (const sourceId of previousSourceIds) {
@@ -16019,6 +17804,22 @@ async function syncManagedSource(rootDir, entry, options) {
         };
       }
       sync = await syncDirectorySource(rootDir, entry.path, entry.repoRoot);
+    } else if (entry.kind === "file") {
+      if (!entry.path) {
+        throw new Error(`Managed source ${entry.id} is missing its file path.`);
+      }
+      if (!await fileExists(entry.path)) {
+        return {
+          ...entry,
+          status: "missing",
+          updatedAt: now,
+          lastSyncAt: now,
+          lastSyncStatus: "error",
+          lastError: `File not found: ${entry.path}`,
+          changed: false
+        };
+      }
+      sync = await syncFileSource(rootDir, entry.path);
     } else if (entry.kind === "github_repo") {
       sync = await syncGitHubRepoSource(rootDir, entry);
     } else {
@@ -16237,6 +18038,179 @@ async function generateBriefsForSources(rootDir, sources) {
   }
   return briefPaths;
 }
+function renderDeterministicSourceReview(input) {
+  const canonicalPages = input.sourcePages.filter((page) => page.kind === "source" || page.kind === "concept" || page.kind === "entity").slice(0, 10);
+  const modulePages = input.sourcePages.filter((page) => page.kind === "module").slice(0, 8);
+  const questions = uniqueStrings4(input.analyses.flatMap((analysis) => analysis.questions)).slice(0, 8);
+  const concepts = uniqueStrings4(input.analyses.flatMap((analysis) => analysis.concepts.map((concept) => concept.name))).slice(0, 8);
+  const entities = uniqueStrings4(input.analyses.flatMap((analysis) => analysis.entities.map((entity) => entity.name))).slice(0, 8);
+  const contradictions = input.report?.contradictions.filter(
+    (contradiction) => input.scope.sourceIds.includes(contradiction.sourceIdA) || input.scope.sourceIds.includes(contradiction.sourceIdB)
+  ) ?? [];
+  return [
+    `# Source Review: ${input.scope.title}`,
+    "",
+    "## What This Source Contains",
+    "",
+    ...input.analyses.length ? input.analyses.map((analysis) => `- ${analysis.title}: ${analysis.summary}`) : ["- This source has not been analyzed yet. Compile the vault before trusting downstream pages."],
+    "",
+    "## Likely Canonical Pages To Update",
+    "",
+    ...canonicalPages.length ? canonicalPages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No canonical source, concept, or entity pages are linked to this source yet."],
+    "",
+    "## Important Topics And Entities",
+    "",
+    ...concepts.length ? [`Concepts: ${concepts.join(", ")}`] : ["Concepts: none detected."],
+    ...entities.length ? [`Entities: ${entities.join(", ")}`] : ["Entities: none detected."],
+    ...modulePages.length ? ["", ...modulePages.map((page) => `- Module: [[${page.path.replace(/\.md$/, "")}|${page.title}]]`)] : [],
+    "",
+    "## Contradictions To Inspect",
+    "",
+    ...contradictions.length ? contradictions.map((contradiction) => `- ${contradiction.claimA} / ${contradiction.claimB}`) : ["- No contradictions are currently flagged for this source scope."],
+    "",
+    "## Open Questions",
+    "",
+    ...questions.length ? questions.map((question) => `- ${question}`) : ["- No extracted open questions yet."],
+    "",
+    "## Suggested Next Steps",
+    "",
+    ...canonicalPages.length ? canonicalPages.slice(0, 5).map((page) => `- Review [[${page.path.replace(/\.md$/, "")}|${page.title}]] for canonical updates.`) : ["- Review the source page and decide which canonical pages should exist."],
+    ""
+  ].join("\n");
+}
+async function generateSourceReviewMarkdown(rootDir, scope) {
+  const { paths } = await loadVaultConfig(rootDir);
+  let graph = await readJsonFile(paths.graphPath);
+  if (!graph) {
+    await compileVault(rootDir, {});
+    graph = await readJsonFile(paths.graphPath);
+  }
+  if (!graph) {
+    return null;
+  }
+  const sourcePages = scopedSourcePages(graph, scope.sourceIds);
+  const analyses = await loadSourceAnalyses(rootDir, scope.sourceIds);
+  const report = await readGraphReport(rootDir);
+  const fallback = renderDeterministicSourceReview({
+    scope,
+    sourcePages,
+    graph,
+    analyses,
+    report
+  });
+  const provider = await getProviderForTask(rootDir, "queryProvider");
+  if (provider.type === "heuristic") {
+    return fallback;
+  }
+  try {
+    const schemas = await loadVaultSchemas(rootDir);
+    const pageContext = sourcePages.slice(0, 12).map((page) => `- ${page.title} (${page.kind}) -> ${page.path}`).join("\n");
+    const analysisContext = analyses.slice(0, 8).map(
+      (analysis) => `# ${analysis.title}
+Summary: ${analysis.summary}
+Questions: ${analysis.questions.join(" | ") || "none"}
+Concepts: ${analysis.concepts.map((concept) => concept.name).join(", ") || "none"}
+Entities: ${analysis.entities.map((entity) => entity.name).join(", ") || "none"}`
+    ).join("\n\n---\n\n");
+    const response = await provider.generateText({
+      system: buildSchemaPrompt(
+        schemas.effective.global,
+        "Write a concise markdown source review with sections: What This Source Contains, Likely Canonical Pages To Update, Important Topics And Entities, Contradictions To Inspect, Open Questions, Suggested Next Steps. Focus on helping a human decide what to keep, update, or question in the wiki."
+      ),
+      prompt: [
+        `Source scope: ${scope.title}`,
+        `Scope id: ${scope.id}`,
+        `Tracked source ids: ${scope.sourceIds.join(", ") || "none"}`,
+        "",
+        "Pages:",
+        pageContext || "- none",
+        "",
+        "Analyses:",
+        analysisContext || "No analysis context available.",
+        "",
+        "Deterministic fallback draft:",
+        fallback
+      ].join("\n")
+    });
+    return response.text?.trim() ? response.text.trim() : fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function stageSourceReviewForScope(rootDir, scope) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const markdown = await generateSourceReviewMarkdown(rootDir, scope);
+  if (!markdown) {
+    throw new Error(`Could not generate a source review for ${scope.id}.`);
+  }
+  const graph = await readJsonFile(paths.graphPath);
+  const relatedPages = graph ? scopedSourcePages(graph, scope.sourceIds) : [];
+  const relatedPageIds = relatedPages.slice(0, 16).map((page) => page.id);
+  const relatedNodeIds = graph ? scopedNodeIds(graph, scope.sourceIds).slice(0, 24) : [];
+  const projectIds = uniqueStrings4(relatedPages.flatMap((page) => page.projectIds));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const output = buildOutputPage({
+    title: `Source Review: ${scope.title}`,
+    question: `Review ${scope.title}`,
+    answer: markdown,
+    citations: scope.sourceIds,
+    schemaHash: graph?.generatedAt ?? "",
+    outputFormat: "report",
+    relatedPageIds,
+    relatedNodeIds,
+    relatedSourceIds: scope.sourceIds,
+    projectIds,
+    extraTags: ["source-review"],
+    origin: "query",
+    slug: `source-reviews/${scope.id}`,
+    metadata: {
+      status: "draft",
+      createdAt: now,
+      updatedAt: now,
+      compiledFrom: scope.sourceIds,
+      managedBy: "system",
+      confidence: 0.79
+    }
+  });
+  const approval = await stageGeneratedOutputPages(rootDir, [{ page: output.page, content: output.content }]);
+  return {
+    sourceId: scope.id,
+    pageId: output.page.id,
+    reviewPath: path25.join(approval.approvalDir, "wiki", output.page.path),
+    staged: true,
+    approvalId: approval.approvalId,
+    approvalDir: approval.approvalDir
+  };
+}
+function scopeFromManagedSource(source) {
+  return {
+    id: source.id,
+    title: source.title,
+    sourceIds: source.sourceIds
+  };
+}
+async function reviewSourceScope(rootDir, scope) {
+  return await stageSourceReviewForScope(rootDir, scope);
+}
+async function reviewManagedSource(rootDir, id) {
+  const managedSources = await loadManagedSources(rootDir);
+  const managedSource = managedSources.find((source) => source.id === id);
+  if (managedSource) {
+    if (!await loadVaultConfig(rootDir).then(({ paths }) => fileExists(paths.graphPath))) {
+      await compileVault(rootDir, {});
+    }
+    return await stageSourceReviewForScope(rootDir, scopeFromManagedSource(managedSource));
+  }
+  const manifest = (await listManifests(rootDir)).find((candidate) => candidate.sourceId === id);
+  if (!manifest) {
+    throw new Error(`Managed source or source id not found: ${id}`);
+  }
+  return await stageSourceReviewForScope(rootDir, {
+    id: manifest.sourceId,
+    title: manifest.title,
+    sourceIds: [manifest.sourceId]
+  });
+}
 function shouldCompile(changedSources, graphExists, compileRequested) {
   return compileRequested && (!graphExists || changedSources.length > 0);
 }
@@ -16247,17 +18221,18 @@ async function listManagedSourceRecords(rootDir) {
 async function addManagedSource(rootDir, input, options = {}) {
   const compileRequested = options.compile ?? true;
   const briefRequested = options.brief ?? true;
+  const reviewRequested = options.review ?? false;
   const sources = await loadManagedSources(rootDir);
   const resolved = await resolveManagedSourceInput(rootDir, input);
   const existing = sources.find((candidate) => matchesManagedSourceSpec(candidate, resolved));
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const source = existing ?? {
-    id: resolved.kind === "directory" ? stableManagedSourceId("directory", path25.resolve(resolved.path), resolved.title) : stableManagedSourceId(resolved.kind, resolved.url, resolved.title),
+    id: resolved.kind === "directory" || resolved.kind === "file" ? stableManagedSourceId(resolved.kind, path25.resolve(resolved.path), resolved.title) : stableManagedSourceId(resolved.kind, resolved.url, resolved.title),
     kind: resolved.kind,
     title: resolved.title,
-    path: resolved.kind === "directory" ? resolved.path : void 0,
+    path: resolved.kind === "directory" || resolved.kind === "file" ? resolved.path : void 0,
     repoRoot: resolved.kind === "directory" ? resolved.repoRoot : void 0,
-    url: resolved.kind === "directory" ? void 0 : resolved.url,
+    url: resolved.kind === "directory" || resolved.kind === "file" ? void 0 : resolved.url,
     createdAt: now,
     updatedAt: now,
     status: "ready",
@@ -16286,15 +18261,18 @@ async function addManagedSource(rootDir, input, options = {}) {
   };
   const nextSources = existing ? sources.map((candidate) => candidate.id === nextSource.id ? nextSource : candidate) : [...sources, nextSource];
   await saveManagedSources(rootDir, nextSources);
+  const review = reviewRequested && nextSource.status === "ready" ? await stageSourceReviewForScope(rootDir, scopeFromManagedSource(nextSource)) : void 0;
   return {
     source: nextSource,
     compile,
-    briefGenerated
+    briefGenerated,
+    review
   };
 }
 async function reloadManagedSources(rootDir, options = {}) {
   const compileRequested = options.compile ?? true;
   const briefRequested = options.brief ?? true;
+  const reviewRequested = options.review ?? false;
   const sources = await loadManagedSources(rootDir);
   const selected = options.all || !options.id ? sources : sources.filter((source) => source.id === options.id);
   if (!selected.length) {
@@ -16330,10 +18308,14 @@ async function reloadManagedSources(rootDir, options = {}) {
     };
   });
   await saveManagedSources(rootDir, nextSources);
+  const reviews = reviewRequested ? await Promise.all(
+    nextSources.filter((source) => selected.some((candidate) => candidate.id === source.id)).filter((source) => source.status === "ready").map(async (source) => await stageSourceReviewForScope(rootDir, scopeFromManagedSource(source)))
+  ) : [];
   return {
     sources: nextSources.filter((source) => selected.some((candidate) => candidate.id === source.id)),
     compile,
-    briefPaths: [...briefPaths.values()]
+    briefPaths: [...briefPaths.values()],
+    reviews
   };
 }
 async function deleteManagedSource(rootDir, id) {
@@ -17237,6 +19219,7 @@ export {
   importInbox,
   ingestDirectory,
   ingestInput,
+  ingestInputDetailed,
   initVault,
   initWorkspace,
   installAgent,
@@ -17267,10 +19250,13 @@ export {
   rejectApproval,
   reloadManagedSources,
   resolvePaths,
+  reviewManagedSource,
+  reviewSourceScope,
   runSchedule,
   runWatchCycle,
   searchVault,
   serveSchedules,
+  stageGeneratedOutputPages,
   startGraphServer,
   startMcpServer,
   syncTrackedRepos,