@swarmvaultai/engine 0.3.0 → 0.4.0

package/dist/index.js

@@ -4504,6 +4504,7 @@ 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";
@@ -5171,6 +5172,508 @@ async function extractEpubChapters(input) {
     };
   }
 }
+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 extractSlackExportDirectory(directoryPath) {
+  const title = path7.basename(directoryPath) || "Slack Export";
+  try {
+    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 parseSlackExportEntries(entries, title);
+  } catch (error) {
+    return {
+      conversations: [],
+      warnings: [`Slack export extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+    };
+  }
+}
 
 // src/logs.ts
 import fs8 from "fs/promises";
@@ -5600,6 +6103,9 @@ 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";
   }
@@ -5612,6 +6118,12 @@ function inferKind(mimeType, filePath) {
   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";
   }
@@ -5636,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);
@@ -5656,6 +6179,53 @@ 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) {
@@ -5886,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);
@@ -6440,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}` });
@@ -6775,7 +7358,7 @@ function preparedMatchesManifest(manifest, prepared, contentHash) {
   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 === "epub" || sourceKind === "csv" || sourceKind === "xlsx" || sourceKind === "pptx" || 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)}`;
@@ -7043,6 +7626,23 @@ async function syncTrackedReposForWatch(rootDir, options, repoRoots) {
 }
 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);
@@ -7072,6 +7672,68 @@ async function prepareFileInputs(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 });
@@ -7094,63 +7756,25 @@ async function prepareFileInputs(rootDir, absoluteInput, repoRoot, sourceClass)
     title = path12.basename(absoluteInput, path12.extname(absoluteInput));
     const extracted = await extractEpubChapters({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
     title = extracted.title?.trim() || title;
-    const groupId = sourceGroupIdFor({
-      title,
-      originType: "file",
-      originalPath: toPosix(absoluteInput)
-    });
     if (extracted.chapters.length) {
-      return extracted.chapters.map(
-        (chapter, index) => finalizePreparedInput({
-          title: `${title} - ${chapter.title}`,
-          originType: "file",
-          sourceKind: "epub",
-          sourceClass,
-          originalPath: toPosix(absoluteInput),
-          repoRelativePath: repoRelativePathFor(absoluteInput, repoRoot),
-          mimeType: "text/markdown",
-          storedExtension: ".md",
-          payloadBytes: Buffer.from(chapter.markdown, "utf8"),
-          extractedText: chapter.markdown,
-          extractionArtifact: {
-            extractor: "epub_text",
-            sourceKind: "epub",
-            mimeType,
-            producedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            metadata: {
-              ...chapter.metadata,
-              chapter_index: String(index + 1),
-              chapter_count: String(extracted.chapters.length)
-            },
-            warnings: extracted.warnings
-          },
-          extractionHash: buildExtractionHash(chapter.markdown, {
-            extractor: "epub_text",
-            sourceKind: "epub",
-            mimeType,
-            producedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            metadata: {
-              ...chapter.metadata,
-              chapter_index: String(index + 1),
-              chapter_count: String(extracted.chapters.length)
-            },
-            warnings: extracted.warnings
-          }),
-          sourceGroupId: groupId,
-          sourceGroupTitle: title,
-          sourcePartKey: chapter.partKey,
-          partIndex: index + 1,
-          partCount: extracted.chapters.length,
-          partTitle: chapter.title,
-          details: {
-            book_title: title,
-            chapter_title: chapter.title,
-            chapter_index: String(index + 1),
-            chapter_count: String(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 = {
@@ -7208,6 +7832,25 @@ async function prepareUrlInputs(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);
@@ -7294,6 +7937,60 @@ async function prepareUrlInputs(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;
@@ -7312,62 +8009,24 @@ async function prepareUrlInputs(rootDir, input, options) {
     } else if (sourceKind === "epub") {
       const extracted = await extractEpubChapters({ mimeType, bytes: payloadBytes, fileName: inputUrl.pathname });
       title = extracted.title?.trim() || title;
-      const groupId = sourceGroupIdFor({
-        title,
-        originType: "url",
-        url: finalUrl
-      });
       if (extracted.chapters.length) {
-        return extracted.chapters.map(
-          (chapter, index) => finalizePreparedInput({
-            title: `${title} - ${chapter.title}`,
-            originType: "url",
-            sourceKind: "epub",
-            url: finalUrl,
-            mimeType: "text/markdown",
-            storedExtension: ".md",
-            payloadBytes: Buffer.from(chapter.markdown, "utf8"),
-            extractedText: chapter.markdown,
-            extractionArtifact: {
-              extractor: "epub_text",
-              sourceKind: "epub",
-              mimeType,
-              producedAt: (/* @__PURE__ */ new Date()).toISOString(),
-              metadata: {
-                ...chapter.metadata,
-                chapter_index: String(index + 1),
-                chapter_count: String(extracted.chapters.length)
-              },
-              warnings: extracted.warnings
-            },
-            extractionHash: buildExtractionHash(chapter.markdown, {
-              extractor: "epub_text",
-              sourceKind: "epub",
-              mimeType,
-              producedAt: (/* @__PURE__ */ new Date()).toISOString(),
-              metadata: {
-                ...chapter.metadata,
-                chapter_index: String(index + 1),
-                chapter_count: String(extracted.chapters.length)
-              },
-              warnings: extracted.warnings
-            }),
-            sourceGroupId: groupId,
-            sourceGroupTitle: title,
-            sourcePartKey: chapter.partKey,
-            partIndex: index + 1,
-            partCount: extracted.chapters.length,
-            partTitle: chapter.title,
-            details: {
-              book_title: title,
-              chapter_title: chapter.title,
-              chapter_index: String(index + 1),
-              chapter_count: String(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
-          })
-        );
+            }
+          })),
+          logDetails
+        });
       }
       extractionArtifact = {
         extractor: "epub_text",
@@ -7544,13 +8203,28 @@ async function prepareInboxHtmlInput(absolutePath, attachmentRefs) {
   };
 }
 function isSupportedInboxKind(sourceKind) {
-  return ["markdown", "text", "html", "pdf", "docx", "epub", "csv", "xlsx", "pptx", "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 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);
 }
@@ -7648,10 +8322,39 @@ 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 = [];
@@ -7716,7 +8419,13 @@ 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;
@@ -9945,6 +10654,19 @@ function relatedOutputsSection(relatedOutputs) {
   }
   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);
   const pageId = `source:${manifest.sourceId}`;
@@ -9968,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 ?? [],
@@ -10300,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",
@@ -10345,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."],
@@ -11821,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 : "",
@@ -11890,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);
@@ -12587,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));
 }
@@ -13612,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
@@ -13717,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")]
   ]) {
@@ -13817,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,
@@ -13855,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")),
@@ -13917,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")]
   ]) {
@@ -13936,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);
   }
@@ -13952,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) {
@@ -14087,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);
@@ -15428,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);
@@ -15648,7 +16748,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.3.0";
+var SERVER_VERSION = "0.4.0";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -16504,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;
@@ -16516,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;
@@ -16552,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(
@@ -16585,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, {
@@ -16679,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 {
@@ -16897,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);
 }
@@ -16907,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",
@@ -16946,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) {
@@ -16990,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) {
@@ -17928,10 +19250,13 @@ export {
   rejectApproval,
   reloadManagedSources,
   resolvePaths,
+  reviewManagedSource,
+  reviewSourceScope,
   runSchedule,
   runWatchCycle,
   searchVault,
   serveSchedules,
+  stageGeneratedOutputPages,
   startGraphServer,
   startMcpServer,
   syncTrackedRepos,