@autorag/librarian 2.0.0 → 2.1.0

package/dist/index.js

@@ -2582,6 +2582,477 @@ var init_eml = __esm(() => {
   };
 });
 
+// src/parser/hwp-markdown.ts
+function renderHwpMarkdown(document) {
+  const tables = new Map;
+  for (const table of document.tables) {
+    const key = `${table.sectionIndex}:${table.parentParagraphIndex}`;
+    const group = tables.get(key) ?? [];
+    group.push(table);
+    tables.set(key, group);
+  }
+  for (const group of tables.values()) {
+    group.sort((left, right) => left.controlIndex - right.controlIndex);
+  }
+  const blocks = [];
+  for (const paragraph of document.paragraphs) {
+    const text = cleanText(paragraph.text);
+    if (hasRenderableText(text))
+      blocks.push(text);
+    for (const table of tables.get(`${paragraph.sectionIndex}:${paragraph.paragraphIndex}`) ?? []) {
+      const rendered = renderTable(table);
+      if (rendered.length > 0)
+        blocks.push(rendered);
+    }
+  }
+  return blocks.join(`
+
+`);
+}
+function cleanText(text) {
+  return text.replace(/[\u0000\uFFFC]/gu, "");
+}
+function hasRenderableText(text) {
+  return text.trim().length > 0;
+}
+function renderTable(table) {
+  const cells = table.cells.map((cell) => ({ ...cell, text: renderCell(cell) }));
+  if (!cells.some((cell) => hasRenderableText(cell.text)))
+    return "";
+  if (cells.some((cell) => cell.rowSpan > 1 || cell.columnSpan > 1))
+    return renderMergedTable(cells);
+  const cellsByPosition = new Map(cells.map((cell) => [`${cell.row}:${cell.column}`, cell.text]));
+  const header = Array.from({ length: table.columnCount }, (_, column) => `Column ${column + 1}`);
+  const rows = Array.from({ length: table.rowCount }, (_, row) => Array.from({ length: table.columnCount }, (_2, column) => cellsByPosition.get(`${row}:${column}`) ?? ""));
+  return [
+    `| ${header.join(" | ")} |`,
+    `| ${header.map(() => "---").join(" | ")} |`,
+    ...rows.map((row) => `| ${row.join(" | ")} |`)
+  ].join(`
+`);
+}
+function renderMergedTable(cells) {
+  const rows = new Map;
+  const coveredPositions = new Set;
+  for (const cell of [...cells].sort((left, right) => left.row - right.row || left.column - right.column)) {
+    const position = `${cell.row}:${cell.column}`;
+    if (coveredPositions.has(position))
+      continue;
+    const row = rows.get(cell.row) ?? [];
+    row.push(cell);
+    rows.set(cell.row, row);
+    for (let rowIndex = cell.row;rowIndex < cell.row + Math.max(1, cell.rowSpan); rowIndex += 1) {
+      for (let columnIndex = cell.column;columnIndex < cell.column + Math.max(1, cell.columnSpan); columnIndex += 1) {
+        if (rowIndex !== cell.row || columnIndex !== cell.column)
+          coveredPositions.add(`${rowIndex}:${columnIndex}`);
+      }
+    }
+  }
+  const renderedRows = [...rows.entries()].sort(([left], [right]) => left - right).map(([row, cellsInRow]) => {
+    const text = cellsInRow.sort((left, right) => left.column - right.column).map((cell) => cell.text).filter(hasRenderableText).join(" | ");
+    return hasRenderableText(text) ? `Row ${row + 1}: ${text}` : "";
+  }).filter((row) => row.length > 0);
+  return ["[Table]", ...renderedRows].join(`
+`);
+}
+function renderCell(cell) {
+  return cell.paragraphs.map(cleanText).filter(hasRenderableText).join("<br>").replaceAll("\\", "\\\\").replace(/\r\n|\r|\n/gu, "<br>").replaceAll("|", "\\|");
+}
+
+// src/parser/rhwp-adapter.ts
+import { readFile } from "node:fs/promises";
+import initRhwp, { HwpDocument } from "@rhwp/core";
+function createRhwpExtractor(runtime = defaultRhwpRuntime, overrides = {}) {
+  const limits = resolveLimits(overrides);
+  const initialize = runtime === defaultRhwpRuntime ? initializeDefaultRhwpRuntime : createRuntimeInitializer(runtime);
+  return async (bytes) => {
+    await initialize();
+    const document = runtime.open(bytes);
+    try {
+      return extractDocument(document, limits);
+    } finally {
+      document.free();
+    }
+  };
+}
+function createRuntimeInitializer(runtime) {
+  let initialization;
+  return () => {
+    if (initialization === undefined) {
+      const attempt = runtime.initialize();
+      initialization = attempt.catch((error) => {
+        initialization = undefined;
+        throw error;
+      });
+    }
+    return initialization;
+  };
+}
+function extractDocument(document, limits) {
+  const paragraphs = [];
+  const paragraphCounts = [];
+  const counters = { characters: 0, tables: 0, cells: 0, cellParagraphs: 0 };
+  const sectionCount = readCount(document.getSectionCount(), "section count");
+  checkBudget("maxSections", sectionCount, limits);
+  for (let sectionIndex = 0;sectionIndex < sectionCount; sectionIndex += 1) {
+    const paragraphCount = readCount(document.getParagraphCount(sectionIndex), `paragraph count for section ${sectionIndex}`);
+    paragraphCounts.push(paragraphCount);
+    checkBudget("maxBodyParagraphs", paragraphs.length + paragraphCount, limits);
+    for (let paragraphIndex = 0;paragraphIndex < paragraphCount; paragraphIndex += 1) {
+      const length = readCount(document.getParagraphLength(sectionIndex, paragraphIndex), `paragraph length at ${sectionIndex}:${paragraphIndex}`);
+      const text = readText(document.getTextRange(sectionIndex, paragraphIndex, 0, length), `paragraph text at ${sectionIndex}:${paragraphIndex}`);
+      counters.characters += [...text].length;
+      checkBudget("maxCharacters", counters.characters, limits);
+      paragraphs.push({
+        sectionIndex,
+        paragraphIndex,
+        text
+      });
+    }
+  }
+  return { paragraphs, tables: extractTables(document, limits, counters, paragraphCounts) };
+}
+function extractTables(document, limits, counters, paragraphCounts) {
+  const tables = [];
+  const seen = new Set;
+  const pageCount = readCount(document.pageCount(), "page count");
+  for (let pageIndex = 0;pageIndex < pageCount; pageIndex += 1) {
+    const layout = readJsonRecord(document.getPageControlLayout(pageIndex), `page ${pageIndex} control layout`);
+    const controls = readArray(layout.controls, `controls for page ${pageIndex}`);
+    for (let layoutIndex = 0;layoutIndex < controls.length; layoutIndex += 1) {
+      const control = readRecord(controls[layoutIndex], `control ${layoutIndex} on page ${pageIndex}`);
+      if (typeof control.type !== "string") {
+        throw new TypeError(`rhwp returned an invalid control type at page ${pageIndex}:${layoutIndex}`);
+      }
+      if (control.type !== "table")
+        continue;
+      const label = `table at page ${pageIndex}:${layoutIndex}`;
+      const coordinates = readTableCoordinates(control, label, paragraphCounts, limits);
+      if (coordinates === undefined)
+        continue;
+      const key = `${coordinates.sectionIndex}:${coordinates.parentParagraphIndex}:${coordinates.controlIndex}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      counters.tables += 1;
+      checkBudget("maxTables", counters.tables, limits);
+      tables.push(extractTable(document, coordinates, limits, counters));
+    }
+  }
+  return tables;
+}
+function readTableCoordinates(control, label, paragraphCounts, limits) {
+  const hasSectionIndex = Object.hasOwn(control, "secIdx");
+  const hasParagraphIndex = Object.hasOwn(control, "paraIdx");
+  const hasControlIndex = Object.hasOwn(control, "controlIdx");
+  const coordinateCount = Number(hasSectionIndex) + Number(hasParagraphIndex) + Number(hasControlIndex);
+  if (coordinateCount === 0) {
+    validateDeferredNestedTable(control, label, limits);
+    return;
+  }
+  if (coordinateCount !== 3) {
+    throw new TypeError(`rhwp returned a partial coordinate set for ${label}`);
+  }
+  if (Object.hasOwn(control, "cellPath") || Object.hasOwn(control, "parentParaIdx")) {
+    throw new TypeError(`rhwp returned conflicting top-level and nested context for ${label}`);
+  }
+  const coordinates = {
+    sectionIndex: readCount(control.secIdx, `secIdx for ${label}`),
+    parentParagraphIndex: readCount(control.paraIdx, `paraIdx for ${label}`),
+    controlIndex: readCount(control.controlIdx, `controlIdx for ${label}`)
+  };
+  const paragraphCount = paragraphCounts[coordinates.sectionIndex];
+  if (paragraphCount === undefined) {
+    throw new TypeError(`rhwp returned a section coordinate outside the announced document range for ${label}`);
+  }
+  if (coordinates.parentParagraphIndex >= paragraphCount) {
+    throw new TypeError(`rhwp returned a parent paragraph coordinate outside the announced section range for ${label}`);
+  }
+  return coordinates;
+}
+function validateDeferredNestedTable(control, label, limits) {
+  if (!Object.hasOwn(control, "cellPath") && !Object.hasOwn(control, "parentParaIdx")) {
+    validateDeferredNestedLayout(control, label, limits);
+    return;
+  }
+  readCount(control.parentParaIdx, `parentParaIdx for deferred nested ${label}`);
+  const cellPath = readArray(control.cellPath, `cellPath for deferred nested ${label}`);
+  if (cellPath.length === 0) {
+    throw new TypeError(`rhwp returned an empty cellPath for deferred nested ${label}`);
+  }
+  checkBudget("maxCells", cellPath.length, limits);
+  for (let pathIndex = 0;pathIndex < cellPath.length; pathIndex += 1) {
+    const entry = readRecord(cellPath[pathIndex], `cellPath entry ${pathIndex} for deferred nested ${label}`);
+    readCount(entry.controlIndex, `controlIndex in cellPath entry ${pathIndex} for deferred nested ${label}`);
+    readCount(entry.cellIndex, `cellIndex in cellPath entry ${pathIndex} for deferred nested ${label}`);
+    readCount(entry.cellParaIndex, `cellParaIndex in cellPath entry ${pathIndex} for deferred nested ${label}`);
+  }
+}
+function validateDeferredNestedLayout(control, label, limits) {
+  readFiniteNumber(control.x, `x for deferred nested ${label}`);
+  readFiniteNumber(control.y, `y for deferred nested ${label}`);
+  readPositiveFiniteNumber(control.w, `w for deferred nested ${label}`);
+  readPositiveFiniteNumber(control.h, `h for deferred nested ${label}`);
+  const rowCount = readPositiveCount(control.rowCount, `rowCount for deferred nested ${label}`);
+  const columnCount = readPositiveCount(control.colCount, `colCount for deferred nested ${label}`);
+  const logicalCellCount = readLogicalCellCount(rowCount, columnCount, limits);
+  readCount(control.plane, `plane for deferred nested ${label}`);
+  readSafeInteger(control.zOrder, `zOrder for deferred nested ${label}`);
+  readCount(control.stableIndex, `stableIndex for deferred nested ${label}`);
+  const cells = readArray(control.cells, `cells for deferred nested ${label}`);
+  if (cells.length === 0) {
+    throw new TypeError(`rhwp returned empty cells for deferred nested ${label}`);
+  }
+  checkBudget("maxCells", cells.length, limits);
+  if (cells.length > logicalCellCount) {
+    throw new TypeError(`rhwp returned too many cells for deferred nested ${label}`);
+  }
+  const anchors = new Set;
+  const cellIndexes = new Set;
+  const coveredCoordinates = new Set;
+  for (let cellIndex = 0;cellIndex < cells.length; cellIndex += 1) {
+    const cell = readRecord(cells[cellIndex], `cell ${cellIndex} for deferred nested ${label}`);
+    readFiniteNumber(cell.x, `x for cell ${cellIndex} in deferred nested ${label}`);
+    readFiniteNumber(cell.y, `y for cell ${cellIndex} in deferred nested ${label}`);
+    readPositiveFiniteNumber(cell.w, `w for cell ${cellIndex} in deferred nested ${label}`);
+    readPositiveFiniteNumber(cell.h, `h for cell ${cellIndex} in deferred nested ${label}`);
+    const row = readCount(cell.row, `row for cell ${cellIndex} in deferred nested ${label}`);
+    const column = readCount(cell.col, `col for cell ${cellIndex} in deferred nested ${label}`);
+    const rowSpan = readPositiveCount(cell.rowSpan, `rowSpan for cell ${cellIndex} in deferred nested ${label}`);
+    const columnSpan = readPositiveCount(cell.colSpan, `colSpan for cell ${cellIndex} in deferred nested ${label}`);
+    const runtimeCellIndex = readCount(cell.cellIdx, `cellIdx for cell ${cellIndex} in deferred nested ${label}`);
+    if (row >= rowCount || rowSpan > rowCount - row) {
+      throw new TypeError(`rhwp returned an out-of-range row span for cell ${cellIndex} in deferred nested ${label}`);
+    }
+    if (column >= columnCount || columnSpan > columnCount - column) {
+      throw new TypeError(`rhwp returned an out-of-range col span for cell ${cellIndex} in deferred nested ${label}`);
+    }
+    if (cellIndexes.has(runtimeCellIndex)) {
+      throw new TypeError(`rhwp returned a duplicate cellIdx for deferred nested ${label}`);
+    }
+    cellIndexes.add(runtimeCellIndex);
+    const anchor = `${row}:${column}`;
+    if (anchors.has(anchor)) {
+      throw new TypeError(`rhwp returned a duplicate cell anchor for deferred nested ${label}`);
+    }
+    anchors.add(anchor);
+    for (let coveredRow = row;coveredRow < row + rowSpan; coveredRow += 1) {
+      for (let coveredColumn = column;coveredColumn < column + columnSpan; coveredColumn += 1) {
+        const coordinate = `${coveredRow}:${coveredColumn}`;
+        if (coveredCoordinates.has(coordinate)) {
+          throw new TypeError(`rhwp returned overlapping cell spans for deferred nested ${label}`);
+        }
+        coveredCoordinates.add(coordinate);
+      }
+    }
+  }
+}
+function extractTable(document, coordinates, limits, counters) {
+  const { sectionIndex, parentParagraphIndex, controlIndex } = coordinates;
+  const key = `${sectionIndex}:${parentParagraphIndex}:${controlIndex}`;
+  const dimensions = readJsonRecord(document.getTableDimensions(sectionIndex, parentParagraphIndex, controlIndex), `table dimensions at ${key}`);
+  const rowCount = readPositiveCount(dimensions.rowCount, `rowCount for table ${key}`);
+  const columnCount = readPositiveCount(dimensions.colCount, `colCount for table ${key}`);
+  const cellCount = readCount(dimensions.cellCount, `cellCount for table ${key}`);
+  const logicalCellCount = chargeLogicalCells(rowCount, columnCount, counters, limits);
+  if (cellCount === 0 || cellCount > logicalCellCount) {
+    throw new TypeError(`rhwp returned an invalid cellCount for table ${key}; expected 1..${logicalCellCount}, received ${cellCount}`);
+  }
+  const cellGeometry = [];
+  const anchors = new Set;
+  const coveredCoordinates = new Set;
+  for (let cellIndex = 0;cellIndex < cellCount; cellIndex += 1) {
+    const cellInfo = readJsonRecord(document.getCellInfo(sectionIndex, parentParagraphIndex, controlIndex, cellIndex), `cell metadata at ${key}:${cellIndex}`);
+    const row = readCount(cellInfo.row, `row for cell ${key}:${cellIndex}`);
+    const column = readCount(cellInfo.col, `col for cell ${key}:${cellIndex}`);
+    const rowSpan = readPositiveCount(cellInfo.rowSpan, `rowSpan for cell ${key}:${cellIndex}`);
+    const columnSpan = readPositiveCount(cellInfo.colSpan, `colSpan for cell ${key}:${cellIndex}`);
+    if (row >= rowCount) {
+      throw new TypeError(`rhwp returned a row outside the table range for cell ${key}:${cellIndex}`);
+    }
+    if (column >= columnCount) {
+      throw new TypeError(`rhwp returned a col outside the table range for cell ${key}:${cellIndex}`);
+    }
+    if (rowSpan > rowCount - row) {
+      throw new TypeError(`rhwp returned a rowSpan outside the table range for cell ${key}:${cellIndex}`);
+    }
+    if (columnSpan > columnCount - column) {
+      throw new TypeError(`rhwp returned a colSpan outside the table range for cell ${key}:${cellIndex}`);
+    }
+    const anchor = row * columnCount + column;
+    if (anchors.has(anchor)) {
+      throw new TypeError(`rhwp returned a duplicate cell anchor for table ${key} at ${row}:${column}`);
+    }
+    anchors.add(anchor);
+    for (let coveredRow = row;coveredRow < row + rowSpan; coveredRow += 1) {
+      for (let coveredColumn = column;coveredColumn < column + columnSpan; coveredColumn += 1) {
+        const coordinate = coveredRow * columnCount + coveredColumn;
+        if (coveredCoordinates.has(coordinate)) {
+          throw new TypeError(`rhwp returned overlapping cell spans for table ${key} at ${coveredRow}:${coveredColumn}`);
+        }
+        coveredCoordinates.add(coordinate);
+      }
+    }
+    cellGeometry.push({ row, column, rowSpan, columnSpan });
+  }
+  if (coveredCoordinates.size !== logicalCellCount) {
+    throw new TypeError(`rhwp returned cellCount ${cellCount} that covers ${coveredCoordinates.size} of ${logicalCellCount} logical grid coordinates for table ${key}`);
+  }
+  const cells = [];
+  for (let cellIndex = 0;cellIndex < cellGeometry.length; cellIndex += 1) {
+    const geometry = cellGeometry[cellIndex];
+    if (geometry === undefined)
+      throw new TypeError(`rhwp omitted cell geometry at ${key}:${cellIndex}`);
+    const paragraphCount = readCount(document.getCellParagraphCount(sectionIndex, parentParagraphIndex, controlIndex, cellIndex), `cell paragraph count at ${key}:${cellIndex}`);
+    counters.cellParagraphs += paragraphCount;
+    checkBudget("maxCellParagraphs", counters.cellParagraphs, limits);
+    const paragraphs = [];
+    for (let cellParagraphIndex = 0;cellParagraphIndex < paragraphCount; cellParagraphIndex += 1) {
+      const length = readCount(document.getCellParagraphLength(sectionIndex, parentParagraphIndex, controlIndex, cellIndex, cellParagraphIndex), `cell paragraph length at ${key}:${cellIndex}:${cellParagraphIndex}`);
+      const text = readText(document.getTextInCell(sectionIndex, parentParagraphIndex, controlIndex, cellIndex, cellParagraphIndex, 0, length), `cell paragraph text at ${key}:${cellIndex}:${cellParagraphIndex}`);
+      counters.characters += [...text].length;
+      checkBudget("maxCharacters", counters.characters, limits);
+      paragraphs.push(text);
+    }
+    cells.push({
+      ...geometry,
+      paragraphs
+    });
+  }
+  return {
+    sectionIndex,
+    parentParagraphIndex,
+    controlIndex,
+    rowCount,
+    columnCount,
+    cells
+  };
+}
+function chargeLogicalCells(rowCount, columnCount, counters, limits) {
+  const logicalCellCount = readLogicalCellCount(rowCount, columnCount, limits);
+  if (logicalCellCount > limits.maxCells - counters.cells) {
+    throw new HwpExtractionBudgetError("maxCells", counters.cells + logicalCellCount, limits.maxCells);
+  }
+  counters.cells += logicalCellCount;
+  return logicalCellCount;
+}
+function readLogicalCellCount(rowCount, columnCount, limits) {
+  if (rowCount > Math.floor(limits.maxCells / columnCount)) {
+    throw new HwpExtractionBudgetError("maxCells", rowCount * columnCount, limits.maxCells);
+  }
+  return rowCount * columnCount;
+}
+function resolveLimits(overrides) {
+  const limits = { ...DEFAULT_LIMITS };
+  for (const name of Object.keys(DEFAULT_LIMITS)) {
+    const value = overrides[name];
+    if (value === undefined)
+      continue;
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`${name} must be a positive finite safe integer`);
+    }
+    limits[name] = value;
+  }
+  return limits;
+}
+function checkBudget(name, actual, limits) {
+  if (actual > limits[name])
+    throw new HwpExtractionBudgetError(name, actual, limits[name]);
+}
+function readCount(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`rhwp returned an invalid ${label}; expected a non-negative safe integer`);
+  }
+  return value;
+}
+function readPositiveCount(value, label) {
+  const count = readCount(value, label);
+  if (count === 0) {
+    throw new TypeError(`rhwp returned an invalid ${label}; expected a positive safe integer`);
+  }
+  return count;
+}
+function readSafeInteger(value, label) {
+  if (!Number.isSafeInteger(value)) {
+    throw new TypeError(`rhwp returned an invalid ${label}; expected a safe integer`);
+  }
+  return value;
+}
+function readFiniteNumber(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(`rhwp returned an invalid ${label}; expected a finite number`);
+  }
+  return value;
+}
+function readPositiveFiniteNumber(value, label) {
+  const number = readFiniteNumber(value, label);
+  if (number <= 0) {
+    throw new TypeError(`rhwp returned an invalid ${label}; expected a positive finite number`);
+  }
+  return number;
+}
+function readText(value, label) {
+  if (typeof value !== "string")
+    throw new TypeError(`rhwp returned invalid ${label}; expected a string`);
+  return value;
+}
+function readJsonRecord(value, label) {
+  const text = readText(value, label);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (cause) {
+    throw new TypeError(`rhwp returned malformed JSON for ${label}`, { cause });
+  }
+  return readRecord(parsed, label);
+}
+function readRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`rhwp returned invalid ${label}; expected an object`);
+  }
+  return value;
+}
+function readArray(value, label) {
+  if (!Array.isArray(value))
+    throw new TypeError(`rhwp returned invalid ${label}; expected an array`);
+  return value;
+}
+var DEFAULT_LIMITS, HwpExtractionBudgetError, defaultRhwpRuntime, initializeDefaultRhwpRuntime;
+var init_rhwp_adapter = __esm(() => {
+  DEFAULT_LIMITS = {
+    maxSections: 256,
+    maxBodyParagraphs: 200000,
+    maxTables: 20000,
+    maxCells: 500000,
+    maxCellParagraphs: 1e6,
+    maxCharacters: 20000000
+  };
+  HwpExtractionBudgetError = class HwpExtractionBudgetError extends Error {
+    code = "HWP_EXTRACTION_BUDGET_EXCEEDED";
+    limit;
+    actual;
+    maximum;
+    constructor(limit, actual, maximum) {
+      super(`HWP extraction exceeded ${limit} budget of ${maximum} (received ${actual})`);
+      this.name = "HwpExtractionBudgetError";
+      this.limit = limit;
+      this.actual = actual;
+      this.maximum = maximum;
+    }
+  };
+  defaultRhwpRuntime = {
+    async initialize() {
+      const rhwpModuleUrl = import.meta.resolve("@rhwp/core");
+      const wasmBytes = await readFile(new URL("./rhwp_bg.wasm", rhwpModuleUrl));
+      await initRhwp({ module_or_path: wasmBytes });
+    },
+    open(bytes) {
+      return new HwpDocument(bytes);
+    }
+  };
+  initializeDefaultRhwpRuntime = createRuntimeInitializer(defaultRhwpRuntime);
+});
+
 // src/parser/xml-text.ts
 import { Buffer as Buffer2 } from "node:buffer";
 import { XMLParser } from "fast-xml-parser";
@@ -2687,15 +3158,25 @@ import { extname as extname2 } from "node:path";
 var HwpParser;
 var init_hwp = __esm(() => {
   init_errors();
+  init_rhwp_adapter();
   init_text();
   init_xml_text();
   HwpParser = class HwpParser extends Parser {
     name = "hwp";
     extensions = [".hwpx", ".hwp"];
+    extractor;
+    constructor(options = {}) {
+      super();
+      this.extractor = options.extractor ?? createRhwpExtractor(undefined, options.limits);
+    }
     async parse(input) {
       try {
         if (extname2(input.virtualPath).toLowerCase() === ".hwp") {
-          throw new Error("legacy HWP5 binary parsing is not supported by the pure JavaScript parser");
+          const document = await this.extractor(input.bytes);
+          return {
+            markdown: normalizeMarkdown(renderHwpMarkdown(document)),
+            metadata: { parser: this.name, format: "hwp5" }
+          };
         }
         const chunks = await readZipXmlText(input.bytes, /^(?:Contents|content)\/.*\.xml$/i);
         return {
@@ -2874,7 +3355,7 @@ var init_office = __esm(() => {
 });
 
 // src/parser/opendataloader-pdf.ts
-import { mkdtemp as mkdtemp2, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdtemp as mkdtemp2, readFile as readFile2, rm, writeFile } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
 import { basename as basename4, join as join12, parse as parse2 } from "node:path";
 import { convert } from "@opendataloader/pdf";
@@ -2917,7 +3398,7 @@ var init_opendataloader_pdf = __esm(() => {
           } : {}
         });
         return {
-          markdown: normalizeMarkdown(await readFile(markdownOutputPath(tempRoot, inputPath), "utf8")),
+          markdown: normalizeMarkdown(await readFile2(markdownOutputPath(tempRoot, inputPath), "utf8")),
           metadata: { parser: this.name }
         };
       } catch (cause) {
@@ -2982,7 +3463,7 @@ function createDefaultParserRegistry(options = {}) {
     new DocxParser,
     new PptxParser,
     new XlsxParser,
-    new HwpParser,
+    new HwpParser(options.hwp),
     new EmlParser
   ];
   if (options.ocr?.enabled)
@@ -3002,7 +3483,7 @@ var init_defaults = __esm(() => {
 // src/mirror/sync.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { existsSync as existsSync10, mkdirSync as mkdirSync6, renameSync as renameSync4, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { opendir, readFile as readFile2, stat } from "node:fs/promises";
+import { opendir, readFile as readFile3, stat } from "node:fs/promises";
 import { dirname as dirname5, extname as extname5, resolve as resolve5 } from "node:path";
 async function syncParsedMirrors(options) {
   const registry = options.registry ?? createDefaultParserRegistry(options.parserOptions);
@@ -3055,7 +3536,7 @@ async function syncParsedMirrors(options) {
     if (!unchanged) {
       let parsed;
       try {
-        const bytes = await readFile2(entry.sourcePath);
+        const bytes = await readFile3(entry.sourcePath);
         parsed = await parser2.parse({ virtualPath: entry.virtualPath, sourcePath: entry.sourcePath, bytes });
       } catch (error) {
         if (!(error instanceof ParseError))
@@ -6335,7 +6816,8 @@ function recordStructuredResultsSession(sessionId, query, details, sessions, mem
     summary: result.summary,
     evidence: result.evidence.map((evidence) => evidence.lineNumber !== undefined ? { excerpt: evidence.excerpt, lineNumber: evidence.lineNumber } : { excerpt: evidence.excerpt }),
     confidence: confidenceFrom(result.confidence),
-    feedbackId: `${sessionId}:${result.number}`
+    feedbackId: `${sessionId}:${result.number}`,
+    source: registry.get(result.number)?.source
   }));
   const answer = details.answer;
   const diagnostics = [];
@@ -8386,155 +8868,2740 @@ var init_agent = __esm(() => {
   TIMESTAMP_TEXT_PATTERN = /^(\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?)(?:\s*;\s*.+)?$/;
 });
 
-// src/index.ts
-init_agent();
-
-// src/agent/index.ts
-init_agent();
-init_datasource_skill();
-init_emit_results_tool();
-init_jikji_find_tool();
-init_search_all_tool();
-init_search_datasource_tool();
-init_search_minsync_tool();
-init_system_prompt();
-
-// src/index.ts
-init_system_prompt();
-
-// src/datasource/index.ts
-init_access_context();
-
-// src/datasource/polling.ts
-function isDue(metadata, now, lastIndexedAt) {
-  if (metadata.mode !== "poll")
-    return false;
-  const intervalMs = metadata.intervalMs;
-  if (intervalMs === undefined || intervalMs <= 0)
-    return false;
-  const last = lastIndexedAt ?? metadata.lastIndexedAt;
-  if (last === undefined)
-    return true;
-  if (!Number.isFinite(now) || !Number.isFinite(last))
-    return false;
-  return now - last >= intervalMs;
-}
-function parseCronExpr(expr) {
-  if (typeof expr !== "string") {
-    return fail("cron expression must be a string");
-  }
-  const trimmed = expr.trim();
-  if (trimmed.length === 0) {
-    return fail("cron expression is empty");
+// src/datasource/connector.ts
+import { createHash as createHash7 } from "node:crypto";
+function connectorFailureToDiagnosticCode(reason) {
+  switch (reason) {
+    case "auth":
+      return "datasource-auth-error";
+    case "permission":
+      return "datasource-permission-denied";
+    case "rate-limited":
+      return "datasource-rate-limited";
+    case "unavailable":
+    case "not-configured":
+      return "datasource-unavailable";
+    case "empty":
+      return "datasource-empty";
+    case "api-error":
+    case "invalid-data":
+      return "datasource-index-failed";
+  }
+}
+function boundDiagnosticText(value) {
+  const trimmed = value.trim();
+  return trimmed.length > 500 ? `${trimmed.slice(0, 500)}...` : trimmed;
+}
+function sanitizeIdSegment(value) {
+  const normalized = value.replace(/[^\p{L}\p{N}._-]+/gu, "-");
+  let start = 0;
+  while (start < normalized.length && (normalized[start] === "-" || normalized[start] === "."))
+    start += 1;
+  let end = normalized.length;
+  while (end > start && (normalized[end - 1] === "-" || normalized[end - 1] === "."))
+    end -= 1;
+  const cleaned = normalized.slice(start, end);
+  if (cleaned === value && cleaned.length > 0 && cleaned.length <= 80)
+    return cleaned;
+  const hash2 = createHash7("sha256").update(value).digest("hex").slice(0, 8);
+  const stem = cleaned.slice(0, 60);
+  return stem.length > 0 ? `${stem}-${hash2}` : hash2;
+}
+var init_connector = () => {};
+
+// src/datasource/chunk-store.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname10, join as join17 } from "node:path";
+function datasourceChunkStorePath(workspaceRoot, skillName, instanceId) {
+  return join17(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId), "chunks.json");
+}
+
+class DatasourceChunkStore {
+  skillName;
+  instanceId;
+  storePath;
+  maxChunkChars;
+  chunkList = [];
+  loaded = false;
+  constructor(options) {
+    this.skillName = options.skillName;
+    this.instanceId = options.instanceId;
+    this.maxChunkChars = options.maxChunkChars ?? DEFAULT_MAX_CHUNK_CHARS;
+    this.storePath = options.workspaceRoot === undefined ? undefined : datasourceChunkStorePath(options.workspaceRoot, options.skillName, options.instanceId);
   }
-  const fields = trimmed.split(/\s+/u);
-  if (fields.length !== 5) {
-    return fail(`expected 5 fields, got ${fields.length}`);
+  replaceDocuments(documents) {
+    const chunks = [];
+    const seenIds = new Set;
+    for (const document of documents) {
+      const docSegment = sanitizeIdSegment(document.docId);
+      const hierarchy = (document.hierarchy ?? []).map(sanitizeIdSegment).filter((segment) => segment.length > 0);
+      const parts = splitContent(document.content, this.maxChunkChars);
+      for (const [index, part] of parts.entries()) {
+        let chunkId = parts.length === 1 ? docSegment : `${docSegment}-p${index + 1}`;
+        while (seenIds.has(chunkId))
+          chunkId = `${chunkId}x`;
+        seenIds.add(chunkId);
+        chunks.push({
+          chunkId,
+          docId: document.docId,
+          hierarchy,
+          ...document.title !== undefined ? { title: document.title } : {},
+          content: part,
+          ...document.publishedAt !== undefined ? { publishedAt: document.publishedAt } : {},
+          metadata: { ...document.metadata ?? {} }
+        });
+      }
+    }
+    this.chunkList = chunks;
+    this.loaded = true;
+    this.persist();
+    return chunks.length;
   }
-  const [minute, hour, dom, month, dow] = fields;
-  const errors = [];
-  validateField(minute, 0, 59, "minute", errors);
-  validateField(hour, 0, 23, "hour", errors);
-  validateField(dom, 1, 31, "day-of-month", errors);
-  validateField(month, 1, 12, "month", errors);
-  validateField(dow, 0, 7, "day-of-week", errors);
-  if (errors.length > 0) {
-    return fail(errors.join("; "));
+  load() {
+    if (this.storePath === undefined)
+      return false;
+    try {
+      if (!existsSync13(this.storePath))
+        return false;
+      const parsed = JSON.parse(readFileSync9(this.storePath, "utf8"));
+      if (parsed.version !== STORE_VERSION || !Array.isArray(parsed.chunks))
+        return false;
+      this.chunkList = parsed.chunks.filter((chunk) => typeof chunk?.chunkId === "string" && typeof chunk?.content === "string");
+      this.loaded = true;
+      return true;
+    } catch {
+      return false;
+    }
   }
-  return { ok: true, expr: trimmed };
-}
-function fail(error) {
-  return { ok: false, error };
-}
-function validateField(field, min, max, label, errors) {
-  const parts = field.split(",");
-  if (parts.length === 0) {
-    errors.push(`${label}: empty`);
-    return;
+  ensureLoaded() {
+    if (!this.loaded) {
+      this.load();
+      this.loaded = true;
+    }
   }
-  for (const part of parts) {
-    const err = validatePart(part, min, max, label);
-    if (err !== null)
-      errors.push(err);
+  chunks() {
+    this.ensureLoaded();
+    return this.chunkList;
   }
-}
-function validatePart(part, min, max, label) {
-  if (part.length === 0)
-    return `${label}: empty term`;
-  const slashIndex = part.indexOf("/");
-  let base = part;
-  let stepText;
-  if (slashIndex >= 0) {
-    base = part.slice(0, slashIndex);
-    stepText = part.slice(slashIndex + 1);
-    const step = parseNumber(stepText);
-    if (step === null || step <= 0) {
-      return `${label}: invalid step "${stepText}"`;
+  hierarchies() {
+    this.ensureLoaded();
+    const seen = new Map;
+    for (const chunk of this.chunkList) {
+      seen.set(chunk.hierarchy.join("/"), chunk.hierarchy);
     }
+    return [...seen.values()];
   }
-  if (base === "*")
-    return null;
-  if (base.includes("-")) {
-    const [loText, hiText] = base.split("-");
-    if (hiText === undefined || loText === undefined) {
-      return `${label}: malformed range "${base}"`;
-    }
-    const lo = parseNumber(loText);
-    const hi = parseNumber(hiText);
-    if (lo === null || hi === null) {
-      return `${label}: non-numeric range "${base}"`;
-    }
-    if (lo < min || lo > max || hi < min || hi > max) {
-      return `${label}: range "${base}" out of bounds (${min}-${max})`;
-    }
-    if (lo > hi) {
-      return `${label}: range "${base}" has low > high`;
+  search(query, topK) {
+    this.ensureLoaded();
+    const queryTerms = [...new Set(tokenize2(query))];
+    if (queryTerms.length === 0 || this.chunkList.length === 0 || topK <= 0)
+      return [];
+    const docCount = this.chunkList.length;
+    const tokenized = this.chunkList.map((chunk) => tokenize2(`${chunk.title ?? ""} ${chunk.content}`));
+    const avgLength = tokenized.reduce((sum, tokens) => sum + tokens.length, 0) / docCount || 1;
+    const termFrequency = (term, tokens) => {
+      let tf = 0;
+      for (const token of tokens) {
+        if (token === term)
+          tf += 1;
+        else if (term.length >= 2 && token.startsWith(term))
+          tf += 0.75;
+      }
+      return tf;
+    };
+    const frequencies = queryTerms.map((term) => tokenized.map((tokens) => termFrequency(term, tokens)));
+    const documentFrequency = frequencies.map((perDoc) => perDoc.reduce((count, tf) => count + (tf > 0 ? 1 : 0), 0));
+    const k1 = 1.2;
+    const b = 0.75;
+    const scored = [];
+    for (const [index, chunk] of this.chunkList.entries()) {
+      const tokens = tokenized[index] ?? [];
+      let score = 0;
+      for (const [termIndex] of queryTerms.entries()) {
+        const df = documentFrequency[termIndex] ?? 0;
+        if (df === 0)
+          continue;
+        const tf = frequencies[termIndex]?.[index] ?? 0;
+        if (tf === 0)
+          continue;
+        const idf = Math.log(1 + (docCount - df + 0.5) / (df + 0.5));
+        score += idf * tf * (k1 + 1) / (tf + k1 * (1 - b + b * tokens.length / avgLength));
+      }
+      if (score > 0)
+        scored.push({ chunk, score });
     }
-    return null;
+    scored.sort((a, b2) => b2.score - a.score || a.chunk.chunkId.localeCompare(b2.chunk.chunkId));
+    return scored.slice(0, topK);
   }
-  const v = parseNumber(base);
-  if (v === null) {
-    return `${label}: invalid value "${base}"`;
+  persist() {
+    if (this.storePath === undefined)
+      return;
+    try {
+      mkdirSync10(dirname10(this.storePath), { recursive: true });
+      const payload = {
+        version: STORE_VERSION,
+        skill: this.skillName,
+        instance: this.instanceId,
+        updatedAt: Date.now(),
+        chunks: this.chunkList
+      };
+      writeFileSync7(this.storePath, `${JSON.stringify(payload)}
+`, "utf8");
+    } catch {}
   }
-  if (v < min || v > max) {
-    return `${label}: value ${v} out of bounds (${min}-${max})`;
+}
+function splitContent(content, maxChars) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0)
+    return [];
+  if (trimmed.length <= maxChars)
+    return [trimmed];
+  const parts = [];
+  const paragraphs = trimmed.split(/\n{2,}/u);
+  let current = "";
+  for (const paragraph of paragraphs) {
+    if (current.length > 0 && current.length + paragraph.length + 2 > maxChars) {
+      parts.push(current);
+      current = "";
+    }
+    if (paragraph.length > maxChars) {
+      if (current.length > 0) {
+        parts.push(current);
+        current = "";
+      }
+      for (let offset = 0;offset < paragraph.length; offset += maxChars) {
+        parts.push(paragraph.slice(offset, offset + maxChars));
+      }
+      continue;
+    }
+    current = current.length === 0 ? paragraph : `${current}
+
+${paragraph}`;
   }
-  return null;
+  if (current.length > 0)
+    parts.push(current);
+  return parts.filter((part) => part.trim().length > 0);
 }
-function parseNumber(text) {
-  if (!/^\d+$/u.test(text))
-    return null;
-  return Number.parseInt(text, 10);
+function tokenize2(text) {
+  return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((token) => token.length > 0);
 }
+var STORE_VERSION = 1, DEFAULT_MAX_CHUNK_CHARS = 2000;
+var init_chunk_store = __esm(() => {
+  init_connector();
+});
+
 // src/datasource/scope.ts
-var DATASOURCE_CHUNKS_SEGMENT = "chunks";
 function buildDatasourceInstanceSource(skillName, instanceId) {
   return normalizeVirtualPath(`/${skillName}/${instanceId}`);
 }
 function buildDatasourceChunkSource(skillName, instanceId, chunkId) {
   return normalizeVirtualPath(`/${skillName}/${instanceId}/${DATASOURCE_CHUNKS_SEGMENT}/${chunkId}`);
 }
-function datasourceSourcePath(skillName, instanceId, chunkId) {
-  return chunkId === undefined ? buildDatasourceInstanceSource(skillName, instanceId) : buildDatasourceChunkSource(skillName, instanceId, chunkId);
+function datasourceSourcePath(skillName, instanceId, chunkId) {
+  return chunkId === undefined ? buildDatasourceInstanceSource(skillName, instanceId) : buildDatasourceChunkSource(skillName, instanceId, chunkId);
+}
+function datasourceSourceHasFragment(source) {
+  return typeof source === "string" && source.includes("#");
+}
+function isDatasourceSource(source) {
+  if (typeof source !== "string" || source.length === 0)
+    return false;
+  if (datasourceSourceHasFragment(source))
+    return false;
+  const normalized = normalizeVirtualPath(source);
+  return normalized !== "/";
+}
+function matchesDatasourceScope(source, scope) {
+  if (datasourceSourceHasFragment(source))
+    return false;
+  return matchesVirtualPathScope(source, scope);
+}
+var DATASOURCE_CHUNKS_SEGMENT = "chunks";
+var init_scope = () => {};
+
+// src/datasource/connector-skill.ts
+class ConnectorDatasourceSkill {
+  definition;
+  connector;
+  instanceId;
+  instances;
+  pollingIntervalMs;
+  tags;
+  store;
+  dedupeWindowMs;
+  lastIndexedAt;
+  lastPolledAt;
+  lastError;
+  seenDocs = new Map;
+  constructor(definition, options) {
+    this.definition = definition;
+    this.connector = options.connector;
+    this.instanceId = options.instanceId ?? DEFAULT_INSTANCE_ID;
+    this.instances = options.instances !== undefined && options.instances.length > 0 ? options.instances : [this.instanceId];
+    this.pollingIntervalMs = options.pollingIntervalMs ?? DEFAULT_POLLING_INTERVAL_MS;
+    this.tags = options.tags ?? definition.defaultTags;
+    this.lastIndexedAt = options.lastIndexedAt;
+    this.dedupeWindowMs = options.dedupeWindowMs ?? 0;
+    this.store = new DatasourceChunkStore({
+      skillName: definition.skillName,
+      instanceId: this.instanceId,
+      workspaceRoot: options.workspaceRoot,
+      maxChunkChars: options.maxChunkChars
+    });
+  }
+  describe() {
+    return {
+      name: this.definition.skillName,
+      id: this.definition.skillName,
+      type: this.definition.skillType,
+      description: this.definition.description,
+      capabilities: this.definition.capabilities,
+      tags: this.tags,
+      status: "active",
+      datasourceId: this.definition.skillName,
+      instanceId: this.instanceId,
+      instances: this.instances
+    };
+  }
+  polling() {
+    return {
+      mode: this.pollingIntervalMs > 0 ? "poll" : "none",
+      ...this.pollingIntervalMs > 0 ? { intervalMs: this.pollingIntervalMs } : {},
+      lastIndexedAt: this.lastIndexedAt,
+      ...this.lastPolledAt !== undefined ? { lastPolledAt: this.lastPolledAt } : {},
+      ...this.lastError !== undefined ? { lastError: this.lastError } : {}
+    };
+  }
+  async index() {
+    this.lastPolledAt = Date.now();
+    let fetched;
+    try {
+      fetched = await this.connector.fetch();
+    } catch {
+      return this.fail("datasource-unavailable", "connector failed unexpectedly");
+    }
+    if (!fetched.ok) {
+      const code = connectorFailureToDiagnosticCode(fetched.reason);
+      const message = boundDiagnosticText(fetched.message ?? fetched.reason);
+      return this.fail(code, `${fetched.reason}: ${message}`);
+    }
+    const documents = this.applyDedupeWindow(fetched.documents);
+    const chunkCount = this.store.replaceDocuments(documents);
+    this.lastIndexedAt = Date.now();
+    this.lastError = undefined;
+    const diagnostics = (fetched.warnings ?? []).map((warning) => ({
+      code: "datasource-index-failed",
+      severity: "warning",
+      message: boundDiagnosticText(warning),
+      instanceId: this.instanceId,
+      source: this.definition.skillName
+    }));
+    if (chunkCount === 0) {
+      diagnostics.push({
+        code: "datasource-empty",
+        severity: "info",
+        message: "datasource fetch returned no indexable documents",
+        instanceId: this.instanceId,
+        source: this.definition.skillName
+      });
+    }
+    return {
+      ok: true,
+      instanceId: this.instanceId,
+      skill: this.definition.skillName,
+      chunkCount,
+      indexedAt: this.lastIndexedAt,
+      diagnostics
+    };
+  }
+  retrievalMethods() {
+    return [
+      new ConnectorLexicalMethod({
+        skillName: this.definition.skillName,
+        skillType: this.definition.skillType,
+        instanceId: this.instanceId,
+        tags: this.tags,
+        store: this.store
+      })
+    ];
+  }
+  describeSources() {
+    const out = this.instances.map((instanceId) => ({
+      source: datasourceSourcePath(this.definition.skillName, instanceId),
+      datasourceId: this.definition.skillName,
+      skill: this.definition.skillName,
+      instanceId,
+      contentType: this.definition.contentType,
+      metadata: {
+        datasourceId: this.definition.skillName,
+        instanceId,
+        tags: this.tags
+      }
+    }));
+    for (const hierarchy of this.store.hierarchies()) {
+      if (hierarchy.length === 0)
+        continue;
+      out.push({
+        source: `${datasourceSourcePath(this.definition.skillName, this.instanceId)}/${hierarchy.join("/")}`,
+        datasourceId: this.definition.skillName,
+        skill: this.definition.skillName,
+        instanceId: this.instanceId,
+        contentType: this.definition.contentType,
+        metadata: {
+          datasourceId: this.definition.skillName,
+          instanceId: this.instanceId,
+          hierarchy
+        }
+      });
+    }
+    return out;
+  }
+  skillManifest() {
+    const skillName = this.definition.skillName;
+    const instanceScopes = this.instances.map((instanceId) => `- \`${datasourceSourcePath(skillName, instanceId)}\``).join(`
+`);
+    const cadence = this.pollingIntervalMs > 0 ? `roughly every ${Math.round(this.pollingIntervalMs / 60000)} minute(s) when auto-refresh runs` : "on manual refresh only";
+    return {
+      name: `datasource-${skillName}`,
+      description: this.definition.manifestDescription,
+      content: [
+        `# ${this.definition.description} (${this.definition.skillType})`,
+        "",
+        "## When to use",
+        this.definition.manifestDescription,
+        "",
+        "## Indexing",
+        `Indexing is server-managed and refreshed ${cadence}. You do not trigger indexing; just search.`,
+        "",
+        "## How to search",
+        "Call `search_datasource_documents` with a natural-language `query`. Optionally pass `topK` and a narrowing `scope`. Available authorized scopes:",
+        instanceScopes.length > 0 ? instanceScopes : "- (no authorized instances)",
+        "",
+        "`scope` can only narrow within already-authorized scopes; it can never widen access.",
+        "",
+        "## Output rules",
+        `Datasource source identifiers such as \`/${skillName}/<instance>/chunks/<id>\` are stable and traceable. Result metadata may carry real file paths or account identifiers; you may cite them in the visible answer when they help the user locate the underlying item. Privacy is the operator's responsibility: run AutoRAG with a local LLM if results must not leave this machine.`,
+        ...this.definition.manifestNotes !== undefined && this.definition.manifestNotes.length > 0 ? ["", ...this.definition.manifestNotes] : []
+      ].join(`
+`)
+    };
+  }
+  applyDedupeWindow(documents) {
+    if (this.dedupeWindowMs <= 0)
+      return documents;
+    const now = Date.now();
+    for (const [docId, seenAt] of this.seenDocs) {
+      if (now - seenAt > this.dedupeWindowMs)
+        this.seenDocs.delete(docId);
+    }
+    const out = [];
+    const inBatch = new Set;
+    for (const document of documents) {
+      if (inBatch.has(document.docId))
+        continue;
+      inBatch.add(document.docId);
+      this.seenDocs.set(document.docId, now);
+      out.push(document);
+    }
+    return out;
+  }
+  fail(code, message) {
+    const sanitized = boundDiagnosticText(message);
+    this.lastError = sanitized;
+    const diagnostic = {
+      code,
+      severity: code === "datasource-unavailable" || code === "datasource-empty" ? "warning" : "error",
+      message: sanitized,
+      instanceId: this.instanceId,
+      source: this.definition.skillName
+    };
+    return {
+      ok: false,
+      instanceId: this.instanceId,
+      skill: this.definition.skillName,
+      indexedAt: Date.now(),
+      diagnostics: [diagnostic],
+      error: sanitized,
+      code,
+      message: sanitized
+    };
+  }
+}
+
+class ConnectorLexicalMethod {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  describe() {
+    const { skillName, skillType, tags } = this.options;
+    return {
+      name: `${skillName}-lexical`,
+      type: "bm25",
+      description: `Lexical retrieval over indexed ${skillType} chunks`,
+      status: "active",
+      capabilities: ["lexical", "scoped", "path-opaque-sources"],
+      datasourceId: skillName,
+      tags: [...tags]
+    };
+  }
+  async retrieve(query, options) {
+    const trimmed = query.trim();
+    if (trimmed.length === 0)
+      return [];
+    const topK = options.topK ?? DEFAULT_TOP_K2;
+    let hits;
+    try {
+      hits = this.options.store.search(trimmed, Math.max(topK * 3, topK));
+    } catch {
+      return [];
+    }
+    const { skillName, instanceId } = this.options;
+    const mapped = [];
+    for (const { chunk, score } of hits) {
+      const source = datasourceSourcePath(skillName, instanceId, chunk.chunkId);
+      if (!this.matchesScope(source, options.scope, options.allowedScopes))
+        continue;
+      mapped.push({
+        id: `${skillName}:${instanceId}:${chunk.chunkId}`,
+        content: chunk.content,
+        source,
+        score,
+        metadata: {
+          ...chunk.metadata,
+          method: `${skillName}-lexical`,
+          datasourceId: skillName,
+          instanceId,
+          chunkId: chunk.chunkId,
+          ...chunk.title !== undefined ? { title: chunk.title } : {},
+          ...chunk.hierarchy.length > 0 ? { hierarchy: chunk.hierarchy.join("/") } : {},
+          ...chunk.publishedAt !== undefined ? { publishedAt: chunk.publishedAt } : {}
+        }
+      });
+      if (mapped.length >= topK)
+        break;
+    }
+    return mapped;
+  }
+  matchesScope(source, scope, allowedScopes) {
+    if (!matchesDatasourceScope(source, scope))
+      return false;
+    if (allowedScopes === undefined || allowedScopes.length === 0)
+      return true;
+    return allowedScopes.some((entry) => matchesDatasourceScope(source, entry));
+  }
+}
+var DEFAULT_POLLING_INTERVAL_MS, DEFAULT_INSTANCE_ID = "default", DEFAULT_TOP_K2 = 20;
+var init_connector_skill = __esm(() => {
+  init_chunk_store();
+  init_connector();
+  init_scope();
+  DEFAULT_POLLING_INTERVAL_MS = 15 * 60 * 1000;
+});
+
+// src/datasource/http.ts
+function combineSignals(timeoutMs, outer) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return outer === undefined ? timeout : AbortSignal.any([timeout, outer]);
+}
+function statusToReason(status) {
+  if (status === 401)
+    return "auth";
+  if (status === 403)
+    return "permission";
+  if (status === 429)
+    return "rate-limited";
+  return "api-error";
+}
+async function requestText(url, options) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      method: options.method ?? "GET",
+      headers: options.headers,
+      body: options.body,
+      signal: combineSignals(timeoutMs, options.signal)
+    });
+  } catch {
+    return { ok: false, reason: "unavailable", message: "request failed or timed out" };
+  }
+  if (!response.ok) {
+    return { ok: false, reason: statusToReason(response.status), message: `http-${response.status}` };
+  }
+  let text;
+  try {
+    text = await response.text();
+  } catch {
+    return { ok: false, reason: "invalid-data", message: "response body unreadable" };
+  }
+  return { ok: true, status: response.status, text };
+}
+function httpText(url, options = {}) {
+  return requestText(url, options);
+}
+async function httpJson(url, options = {}) {
+  const result = await requestText(url, options);
+  if (!result.ok)
+    return result;
+  try {
+    return { ok: true, status: result.status, json: JSON.parse(result.text) };
+  } catch {
+    return { ok: false, reason: "invalid-data", message: "response was not valid JSON" };
+  }
+}
+function asRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function parseEpochMs(value) {
+  if (typeof value !== "string" || value.length === 0)
+    return;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
+function resolveToken(token, tokenEnv) {
+  if (token !== undefined && token.length > 0)
+    return token;
+  if (tokenEnv !== undefined && tokenEnv.length > 0) {
+    const fromEnv = process.env[tokenEnv];
+    if (fromEnv !== undefined && fromEnv.length > 0)
+      return fromEnv;
+  }
+  return;
+}
+var DEFAULT_TIMEOUT_MS3 = 15000;
+
+// src/datasource/skills/discord/connector.ts
+class DiscordConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV);
+    if (token === undefined)
+      return { ok: false, reason: "not-configured", message: "auth token not configured" };
+    const guildId = this.options.guildId;
+    if (guildId === undefined || guildId.length === 0) {
+      return { ok: false, reason: "not-configured", message: "guild id not configured" };
+    }
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL;
+    const request = {
+      headers: { Authorization: `Bot ${token}` },
+      timeoutMs: this.options.timeoutMs,
+      fetchImpl: this.options.fetchImpl,
+      signal
+    };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS;
+    const listResult = await httpJson(`${baseUrl}/guilds/${guildId}/channels`, request);
+    if (!listResult.ok) {
+      return { ok: false, reason: listResult.reason, message: `channel list failed: ${listResult.message}` };
+    }
+    const channels = [];
+    for (const raw of asArray(listResult.json)) {
+      const channel = asRecord2(raw);
+      const id = asString(channel?.id);
+      const name = asString(channel?.name);
+      const type = asNumber(channel?.type);
+      if (id === undefined || name === undefined || type === undefined)
+        continue;
+      if (!TEXT_CHANNEL_TYPES.has(type))
+        continue;
+      channels.push({ id, name });
+    }
+    const filter = this.options.channels;
+    const selected = filter === undefined || filter.length === 0 ? channels : channels.filter((channel) => filter.includes(channel.id) || filter.includes(channel.name));
+    const documents = [];
+    const warnings = [];
+    for (const channel of selected) {
+      if (documents.length >= maxDocuments)
+        break;
+      let before;
+      for (let page = 0;page < maxPages && documents.length < maxDocuments; page += 1) {
+        const url = new URL(`${baseUrl}/channels/${channel.id}/messages`);
+        url.searchParams.set("limit", "100");
+        if (before !== undefined)
+          url.searchParams.set("before", before);
+        const result = await httpJson(url.toString(), request);
+        if (!result.ok) {
+          if (result.reason === "rate-limited") {
+            return { ok: false, reason: "rate-limited", message: "discord: rate limited" };
+          }
+          if (result.reason === "permission") {
+            warnings.push(`channel ${channel.name} skipped: missing permission`);
+          } else {
+            warnings.push(`channel ${channel.name} history failed: ${result.message}`);
+          }
+          break;
+        }
+        const messages = asArray(result.json);
+        if (messages.length === 0)
+          break;
+        let lastId;
+        for (const raw of messages) {
+          const message = asRecord2(raw);
+          const id = asString(message?.id);
+          if (id !== undefined)
+            lastId = id;
+          if (documents.length >= maxDocuments)
+            continue;
+          const content = asString(message?.content);
+          if (message === undefined || id === undefined || content === undefined || content.length === 0)
+            continue;
+          const author = asString(asRecord2(message.author)?.username) ?? "unknown";
+          documents.push({
+            docId: `${channel.id}-${id}`,
+            hierarchy: ["channels", channel.name],
+            title: `#${channel.name}`,
+            content: `${author}: ${content}`,
+            publishedAt: parseEpochMs(message.timestamp),
+            metadata: { channelId: channel.id, messageId: id, author }
+          });
+        }
+        if (lastId === undefined || messages.length < 100)
+          break;
+        before = lastId;
+      }
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+var DEFAULT_BASE_URL = "https://discord.com/api/v10", DEFAULT_TOKEN_ENV = "DISCORD_BOT_TOKEN", DEFAULT_MAX_PAGES = 10, DEFAULT_MAX_DOCUMENTS = 500, TEXT_CHANNEL_TYPES;
+var init_connector2 = __esm(() => {
+  TEXT_CHANNEL_TYPES = new Set([0, 5]);
+});
+
+// src/datasource/skills/discord/skill.ts
+var DISCORD_SKILL_DEFINITION, DiscordSkill;
+var init_skill = __esm(() => {
+  init_connector_skill();
+  init_connector2();
+  DISCORD_SKILL_DEFINITION = {
+    skillName: "discord",
+    skillType: "discord-guild",
+    description: "Discord guild datasource",
+    capabilities: ["chat", "api", "polling"],
+    defaultTags: ["discord", "chat", "pii"],
+    contentType: "chat",
+    manifestDescription: "Search indexed Discord messages across authorized guild channels and threads. Use for questions about Discord conversations or community discussions.",
+    manifestNotes: ["Channel visibility and history windows are bounded by the server-configured bot permissions."]
+  };
+  DiscordSkill = class DiscordSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(DISCORD_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new DiscordConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/discord/index.ts
+var init_discord = __esm(() => {
+  init_connector2();
+  init_skill();
+});
+
+// src/datasource/skills/gdrive/connector.ts
+class GDriveConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV2);
+    if (token === undefined)
+      return { ok: false, reason: "not-configured", message: "auth token not configured" };
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL2;
+    const request = {
+      headers: { Authorization: `Bearer ${token}` },
+      timeoutMs: this.options.timeoutMs,
+      fetchImpl: this.options.fetchImpl,
+      signal
+    };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES2;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS2;
+    const files = [];
+    let pageToken;
+    for (let page = 0;page < maxPages; page += 1) {
+      const url = new URL(`${baseUrl}/files`);
+      url.searchParams.set("pageSize", "100");
+      url.searchParams.set("fields", "nextPageToken,files(id,name,mimeType,modifiedTime,parents)");
+      const query = this.options.folderId !== undefined ? `trashed=false and '${this.options.folderId}' in parents` : "trashed=false";
+      url.searchParams.set("q", query);
+      if (this.options.includeSharedDrives === true) {
+        url.searchParams.set("supportsAllDrives", "true");
+        url.searchParams.set("includeItemsFromAllDrives", "true");
+        url.searchParams.set("corpora", "allDrives");
+      }
+      if (pageToken !== undefined)
+        url.searchParams.set("pageToken", pageToken);
+      const result = await httpJson(url.toString(), request);
+      if (!result.ok)
+        return { ok: false, reason: result.reason, message: `file list failed: ${result.message}` };
+      const envelope = asRecord2(result.json);
+      if (envelope === undefined)
+        return { ok: false, reason: "invalid-data", message: "file list malformed" };
+      for (const raw of asArray(envelope.files)) {
+        const file = asRecord2(raw);
+        const id = asString(file?.id);
+        const name = asString(file?.name);
+        const mimeType = asString(file?.mimeType);
+        if (id === undefined || name === undefined || mimeType === undefined)
+          continue;
+        files.push({ id, name, mimeType, modifiedTime: asString(file?.modifiedTime) });
+      }
+      pageToken = asString(envelope.nextPageToken);
+      if (pageToken === undefined || pageToken.length === 0)
+        break;
+    }
+    const documents = [];
+    const warnings = [];
+    for (const file of files) {
+      if (documents.length >= maxDocuments)
+        break;
+      const exportMime = EXPORT_MIME[file.mimeType];
+      let contentUrl;
+      if (exportMime !== undefined) {
+        contentUrl = `${baseUrl}/files/${file.id}/export?mimeType=${encodeURIComponent(exportMime)}`;
+      } else if (DOWNLOAD_MIME.has(file.mimeType)) {
+        contentUrl = `${baseUrl}/files/${file.id}?alt=media`;
+      } else {
+        continue;
+      }
+      const contentResult = await httpText(contentUrl, request);
+      if (!contentResult.ok) {
+        warnings.push(`file export failed: ${contentResult.message}`);
+        continue;
+      }
+      const content = contentResult.text.trim().slice(0, MAX_CONTENT_CHARS);
+      if (content.length === 0)
+        continue;
+      documents.push({
+        docId: file.id,
+        hierarchy: ["files"],
+        title: file.name,
+        content,
+        publishedAt: parseEpochMs(file.modifiedTime),
+        metadata: {
+          mimeType: file.mimeType,
+          ...file.modifiedTime !== undefined ? { modifiedTime: file.modifiedTime } : {}
+        }
+      });
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+var DEFAULT_BASE_URL2 = "https://www.googleapis.com/drive/v3", DEFAULT_TOKEN_ENV2 = "GDRIVE_ACCESS_TOKEN", DEFAULT_MAX_PAGES2 = 10, DEFAULT_MAX_DOCUMENTS2 = 500, MAX_CONTENT_CHARS = 1e5, EXPORT_MIME, DOWNLOAD_MIME;
+var init_connector3 = __esm(() => {
+  EXPORT_MIME = {
+    "application/vnd.google-apps.document": "text/plain",
+    "application/vnd.google-apps.spreadsheet": "text/csv"
+  };
+  DOWNLOAD_MIME = new Set(["text/plain", "text/markdown", "text/csv", "application/json"]);
+});
+
+// src/datasource/skills/gdrive/rclone-connector.ts
+import { spawn as spawn5 } from "node:child_process";
+
+class RcloneConnector {
+  options;
+  runner;
+  constructor(options = {}) {
+    this.options = options;
+    this.runner = options.runner ?? ((args, timeoutMs) => runBinary(options.binaryPath ?? DEFAULT_BINARY2, args, timeoutMs));
+  }
+  async fetch() {
+    const remote = this.options.remote;
+    if (remote === undefined || remote.length === 0) {
+      return { ok: false, reason: "not-configured", message: "rclone remote not configured" };
+    }
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS4;
+    const exportFormats = this.options.exportFormats ?? DEFAULT_EXPORT_FORMATS;
+    const extensions = this.options.extensions ?? DEFAULT_EXTENSIONS;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS3;
+    const maxBytes = this.options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE;
+    let listResult;
+    try {
+      listResult = await this.runner(["lsjson", remote, "--recursive", "--files-only", "--drive-export-formats", exportFormats], timeoutMs);
+    } catch {
+      return { ok: false, reason: "unavailable", message: "rclone binary not found or failed to spawn" };
+    }
+    if (!listResult.ok) {
+      return { ok: false, reason: classifyFailure(listResult.stderr), message: shortFailure(listResult) };
+    }
+    let entries;
+    try {
+      entries = asArray(JSON.parse(listResult.stdout));
+    } catch {
+      return { ok: false, reason: "invalid-data", message: "rclone listing was not valid JSON" };
+    }
+    const documents = [];
+    let readFailures = 0;
+    let skipped = 0;
+    for (const raw of entries) {
+      if (documents.length >= maxDocuments)
+        break;
+      const entry = asRecord2(raw);
+      const path = asString(entry?.Path);
+      const name = asString(entry?.Name);
+      if (entry === undefined || path === undefined || name === undefined)
+        continue;
+      const extension = name.includes(".") ? name.slice(name.lastIndexOf(".")).toLowerCase() : "";
+      if (!extensions.includes(extension)) {
+        skipped += 1;
+        continue;
+      }
+      const size = typeof entry.Size === "number" ? entry.Size : 0;
+      if (size > maxBytes) {
+        skipped += 1;
+        continue;
+      }
+      const target = remote.endsWith(":") || remote.endsWith("/") ? `${remote}${path}` : `${remote}/${path}`;
+      let content = "";
+      try {
+        const catResult = await this.runner(["cat", target, "--drive-export-formats", exportFormats, "--count", String(maxBytes)], timeoutMs);
+        if (!catResult.ok) {
+          readFailures += 1;
+          continue;
+        }
+        content = catResult.stdout.trim().slice(0, MAX_CONTENT_CHARS2);
+      } catch {
+        readFailures += 1;
+        continue;
+      }
+      if (content.length === 0)
+        continue;
+      const segments = path.split("/");
+      documents.push({
+        docId: path,
+        hierarchy: ["files", ...segments.slice(0, -1)],
+        title: name,
+        content,
+        publishedAt: parseEpochMs(asString(entry.ModTime)),
+        metadata: {
+          ...asString(entry.MimeType) !== undefined ? { mimeType: asString(entry.MimeType) } : {},
+          size
+        }
+      });
+    }
+    const warnings = [];
+    if (readFailures > 0)
+      warnings.push(`${readFailures} file(s) failed to read`);
+    if (skipped > 0)
+      warnings.push(`${skipped} file(s) skipped (non-text or oversized)`);
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+function classifyFailure(stderr) {
+  const lower = stderr.toLowerCase();
+  if (lower.includes("didn't find section") || lower.includes("config file") || lower.includes("no remotes")) {
+    return "not-configured";
+  }
+  if (lower.includes("oauth") || lower.includes("token") || lower.includes("unauthorized") || lower.includes("401")) {
+    return "auth";
+  }
+  if (lower.includes("permission") || lower.includes("403") || lower.includes("forbidden"))
+    return "permission";
+  return "api-error";
+}
+function shortFailure(result) {
+  return `rclone exited with code ${result.code ?? "unknown"}`;
+}
+function runBinary(binary, args, timeoutMs) {
+  return new Promise((resolvePromise) => {
+    const child = spawn5(binary, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolvePromise({ ok: false, stdout, stderr, code: null });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolvePromise({ ok: code === 0, stdout, stderr, code });
+    });
+  });
+}
+var DEFAULT_BINARY2 = "rclone", DEFAULT_EXTENSIONS, DEFAULT_EXPORT_FORMATS = "txt,csv", DEFAULT_MAX_DOCUMENTS3 = 200, DEFAULT_MAX_BYTES_PER_FILE, DEFAULT_TIMEOUT_MS4 = 60000, MAX_CONTENT_CHARS2 = 1e5;
+var init_rclone_connector = __esm(() => {
+  DEFAULT_EXTENSIONS = [".txt", ".md", ".csv", ".json", ".html", ".rst", ".org"];
+  DEFAULT_MAX_BYTES_PER_FILE = 2 * 1024 * 1024;
+});
+
+// src/datasource/skills/gdrive/skill.ts
+var GDRIVE_SKILL_DEFINITION, GDriveSkill;
+var init_skill2 = __esm(() => {
+  init_connector_skill();
+  init_connector3();
+  GDRIVE_SKILL_DEFINITION = {
+    skillName: "gdrive",
+    skillType: "google-drive",
+    description: "Google Drive datasource",
+    capabilities: ["documents", "api", "polling"],
+    defaultTags: ["gdrive", "documents", "pii"],
+    contentType: "document",
+    manifestDescription: "Search indexed Google Drive documents (Docs, Sheets, plain text). Use for questions about files stored in the authorized Drive account or folder.",
+    manifestNotes: [
+      "Shared-drive permissions are enforced by the server-configured OAuth token; unexported binary formats are not indexed."
+    ]
+  };
+  GDriveSkill = class GDriveSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(GDRIVE_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new GDriveConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/gdrive/index.ts
+var init_gdrive = __esm(() => {
+  init_connector3();
+  init_rclone_connector();
+  init_skill2();
+});
+
+// src/datasource/skills/github/connector.ts
+class GitHubConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const repos = this.options.repos ?? [];
+    if (repos.length === 0)
+      return { ok: false, reason: "not-configured", message: "no repositories configured" };
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV3);
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL3;
+    const request = {
+      headers: {
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "User-Agent": "autorag-datasource",
+        ...token !== undefined ? { Authorization: `Bearer ${token}` } : {}
+      },
+      timeoutMs: this.options.timeoutMs,
+      fetchImpl: this.options.fetchImpl,
+      signal
+    };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES3;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS4;
+    const documents = [];
+    const warnings = [];
+    for (const repo of repos) {
+      if (documents.length >= maxDocuments)
+        break;
+      const [owner, name] = repo.split("/", 2);
+      if (owner === undefined || name === undefined || owner.length === 0 || name.length === 0) {
+        warnings.push(`repository entry ${repos.indexOf(repo) + 1} is not owner/repo`);
+        continue;
+      }
+      for (let page = 1;page <= maxPages && documents.length < maxDocuments; page += 1) {
+        const url = `${baseUrl}/repos/${owner}/${name}/issues?state=all&per_page=100&page=${page}`;
+        const result = await httpJson(url, request);
+        if (!result.ok) {
+          if (result.reason === "auth")
+            return { ok: false, reason: "auth", message: "github: unauthorized" };
+          if (result.reason === "rate-limited" || result.reason === "permission") {
+            return { ok: false, reason: "rate-limited", message: "github: rate limited or forbidden" };
+          }
+          warnings.push(`repo ${owner}-${name} fetch failed: ${result.message}`);
+          break;
+        }
+        const items = asArray(result.json);
+        if (items.length === 0)
+          break;
+        for (const raw of items) {
+          if (documents.length >= maxDocuments)
+            break;
+          const item = asRecord2(raw);
+          const number = asNumber(item?.number);
+          const title = asString(item?.title);
+          if (item === undefined || number === undefined || title === undefined)
+            continue;
+          const isPull = asRecord2(item.pull_request) !== undefined;
+          const body = asString(item.body) ?? "";
+          const labels = asArray(item.labels).map((label) => asString(asRecord2(label)?.name)).filter((label) => label !== undefined);
+          documents.push({
+            docId: `${owner}-${name}-${number}`,
+            hierarchy: [owner, name, isPull ? "pulls" : "issues"],
+            title: `#${number} ${title}`,
+            content: body.length > 0 ? `${title}
+
+${body}` : title,
+            publishedAt: parseEpochMs(item.updated_at),
+            metadata: {
+              state: asString(item.state) ?? "unknown",
+              number,
+              kind: isPull ? "pull" : "issue",
+              labels
+            }
+          });
+        }
+        if (items.length < 100)
+          break;
+      }
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+var DEFAULT_BASE_URL3 = "https://api.github.com", DEFAULT_TOKEN_ENV3 = "GITHUB_TOKEN", DEFAULT_MAX_PAGES3 = 10, DEFAULT_MAX_DOCUMENTS4 = 500;
+var init_connector4 = () => {};
+
+// src/datasource/skills/github/skill.ts
+var GITHUB_SKILL_DEFINITION, GitHubSkill;
+var init_skill3 = __esm(() => {
+  init_connector_skill();
+  init_connector4();
+  GITHUB_SKILL_DEFINITION = {
+    skillName: "github",
+    skillType: "github-issues",
+    description: "GitHub Issues/PRs datasource",
+    capabilities: ["issues", "api", "polling"],
+    defaultTags: ["github", "issues"],
+    contentType: "issue",
+    manifestDescription: "Search indexed GitHub issues and pull requests for the configured repositories. Use for questions about bug reports, feature requests, and review discussions.",
+    manifestNotes: ["Repository visibility is bounded by the server-configured token scopes."]
+  };
+  GitHubSkill = class GitHubSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(GITHUB_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new GitHubConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/github/index.ts
+var init_github = __esm(() => {
+  init_connector4();
+  init_skill3();
+});
+
+// src/datasource/skills/gmail/himalaya-connector.ts
+import { spawn as spawn6 } from "node:child_process";
+
+class HimalayaConnector {
+  options;
+  runner;
+  constructor(options = {}) {
+    this.options = options;
+    this.runner = options.runner ?? ((args, timeoutMs) => runBinary2(options.binaryPath ?? DEFAULT_BINARY3, args, timeoutMs));
+  }
+  async fetch() {
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS5;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS5;
+    const accountArgs = this.options.account !== undefined ? ["--account", this.options.account] : [];
+    const folderArgs = this.options.folder !== undefined ? ["--folder", this.options.folder] : [];
+    const listArgs = [
+      "envelope",
+      "list",
+      ...accountArgs,
+      ...folderArgs,
+      "--page-size",
+      String(this.options.pageSize ?? DEFAULT_PAGE_SIZE),
+      "--output",
+      "json"
+    ];
+    let listResult;
+    try {
+      listResult = await this.runner(listArgs, timeoutMs);
+    } catch {
+      return { ok: false, reason: "unavailable", message: "himalaya binary not found or failed to spawn" };
+    }
+    if (!listResult.ok) {
+      return { ok: false, reason: classifyFailure2(listResult.stderr), message: shortFailure2(listResult) };
+    }
+    let envelopes;
+    try {
+      envelopes = asArray(JSON.parse(listResult.stdout));
+    } catch {
+      return { ok: false, reason: "invalid-data", message: "envelope listing was not valid JSON" };
+    }
+    const account = this.options.account ?? "default";
+    const folder = this.options.folder ?? "INBOX";
+    const documents = [];
+    let readFailures = 0;
+    for (const raw of envelopes.slice(0, maxDocuments)) {
+      const envelope = asRecord2(raw);
+      const id = asString(envelope?.id);
+      if (envelope === undefined || id === undefined)
+        continue;
+      const subject = asString(envelope.subject) ?? "(no subject)";
+      const from = asRecord2(envelope.from);
+      const fromText = [asString(from?.name), asString(from?.addr)].filter(Boolean).join(" ").trim();
+      let body = "";
+      try {
+        const readResult = await this.runner(["message", "read", ...accountArgs, ...folderArgs, id], timeoutMs);
+        if (readResult.ok)
+          body = readResult.stdout.trim().slice(0, MAX_BODY_CHARS);
+        else
+          readFailures += 1;
+      } catch {
+        readFailures += 1;
+      }
+      const headerBlock = [
+        `Subject: ${subject}`,
+        ...fromText.length > 0 ? [`From: ${fromText}`] : [],
+        ...asString(envelope.date) !== undefined ? [`Date: ${asString(envelope.date)}`] : []
+      ].join(`
+`);
+      documents.push({
+        docId: `${account}-${folder}-${id}`,
+        hierarchy: ["accounts", account, folder],
+        title: subject,
+        content: body.length > 0 ? `${headerBlock}
+
+${body}` : headerBlock,
+        publishedAt: parseHimalayaDate(asString(envelope.date)),
+        metadata: {
+          account,
+          folder,
+          messageId: id,
+          ...asArray(envelope.flags).length > 0 ? {
+            flags: asArray(envelope.flags).map((flag) => asString(flag)).filter(Boolean)
+          } : {}
+        }
+      });
+    }
+    const warnings = readFailures > 0 ? [`${readFailures} message(s) failed to read`] : undefined;
+    return { ok: true, documents, ...warnings !== undefined ? { warnings } : {} };
+  }
+}
+function parseHimalayaDate(value) {
+  if (value === undefined || value.length === 0)
+    return;
+  const parsed = Date.parse(value.replace(" ", "T"));
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
+function classifyFailure2(stderr) {
+  const lower = stderr.toLowerCase();
+  if (lower.includes("cannot find") && lower.includes("account"))
+    return "not-configured";
+  if (lower.includes("auth") || lower.includes("login") || lower.includes("credential"))
+    return "auth";
+  return "api-error";
+}
+function shortFailure2(result) {
+  return `himalaya exited with code ${result.code ?? "unknown"}`;
+}
+function runBinary2(binary, args, timeoutMs) {
+  return new Promise((resolvePromise) => {
+    const child = spawn6(binary, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolvePromise({ ok: false, stdout, stderr, code: null });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolvePromise({ ok: code === 0, stdout, stderr, code });
+    });
+  });
+}
+var DEFAULT_BINARY3 = "himalaya", DEFAULT_PAGE_SIZE = 100, DEFAULT_MAX_DOCUMENTS5 = 50, DEFAULT_TIMEOUT_MS5 = 30000, MAX_BODY_CHARS = 50000;
+var init_himalaya_connector = () => {};
+
+// src/datasource/skills/gmail/connector.ts
+class GmailConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV4);
+    if (token === undefined)
+      return { ok: false, reason: "not-configured", message: "auth token not configured" };
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL4;
+    const request = {
+      headers: { Authorization: `Bearer ${token}` },
+      timeoutMs: this.options.timeoutMs,
+      fetchImpl: this.options.fetchImpl,
+      signal
+    };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES4;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS6;
+    const messageIds = [];
+    let pageToken;
+    for (let page = 0;page < maxPages && messageIds.length < maxDocuments; page += 1) {
+      const url = new URL(`${baseUrl}/users/me/messages`);
+      url.searchParams.set("maxResults", "100");
+      for (const labelId of this.options.labelIds ?? [])
+        url.searchParams.append("labelIds", labelId);
+      if (this.options.query !== undefined)
+        url.searchParams.set("q", this.options.query);
+      if (pageToken !== undefined)
+        url.searchParams.set("pageToken", pageToken);
+      const result = await httpJson(url.toString(), request);
+      if (!result.ok)
+        return { ok: false, reason: result.reason, message: `message list failed: ${result.message}` };
+      const envelope = asRecord2(result.json);
+      if (envelope === undefined)
+        return { ok: false, reason: "invalid-data", message: "message list malformed" };
+      for (const raw of asArray(envelope.messages)) {
+        const id = asString(asRecord2(raw)?.id);
+        if (id !== undefined)
+          messageIds.push(id);
+      }
+      pageToken = asString(envelope.nextPageToken);
+      if (pageToken === undefined || pageToken.length === 0)
+        break;
+    }
+    const documents = [];
+    let failedFetches = 0;
+    for (const id of messageIds.slice(0, maxDocuments)) {
+      const result = await httpJson(`${baseUrl}/users/me/messages/${id}?format=full`, request);
+      if (!result.ok) {
+        if (result.reason === "auth")
+          return { ok: false, reason: "auth", message: "gmail: unauthorized" };
+        if (result.reason === "rate-limited") {
+          return { ok: false, reason: "rate-limited", message: "gmail: rate limited" };
+        }
+        failedFetches += 1;
+        continue;
+      }
+      const message = asRecord2(result.json);
+      if (message === undefined) {
+        failedFetches += 1;
+        continue;
+      }
+      const payload = asRecord2(message.payload);
+      const headers = headerMap(payload);
+      const subject = headers.get("subject") ?? "(no subject)";
+      const body = (extractBody(payload) ?? asString(message.snippet) ?? "").slice(0, MAX_BODY_CHARS2);
+      const labelIds = asArray(message.labelIds).map((label) => asString(label)).filter((label) => label !== undefined);
+      const internalDate = asString(message.internalDate);
+      const publishedAt = internalDate !== undefined && /^\d+$/u.test(internalDate) ? Number(internalDate) : undefined;
+      const headerBlock = [
+        `Subject: ${subject}`,
+        ...headers.has("from") ? [`From: ${headers.get("from")}`] : [],
+        ...headers.has("to") ? [`To: ${headers.get("to")}`] : [],
+        ...headers.has("date") ? [`Date: ${headers.get("date")}`] : []
+      ].join(`
+`);
+      documents.push({
+        docId: id,
+        hierarchy: ["labels", this.options.labelIds?.[0] ?? "all"],
+        title: subject,
+        content: `${headerBlock}
+
+${body}`.trim(),
+        ...publishedAt !== undefined ? { publishedAt } : {},
+        metadata: {
+          ...asString(message.threadId) !== undefined ? { threadId: asString(message.threadId) } : {},
+          labelIds
+        }
+      });
+    }
+    const warnings = failedFetches > 0 ? [`${failedFetches} message(s) failed to fetch`] : undefined;
+    return { ok: true, documents, ...warnings !== undefined ? { warnings } : {} };
+  }
+}
+function headerMap(payload) {
+  const map = new Map;
+  for (const raw of asArray(payload?.headers)) {
+    const header = asRecord2(raw);
+    const name = asString(header?.name)?.toLowerCase();
+    const value = asString(header?.value);
+    if (name !== undefined && value !== undefined && !map.has(name))
+      map.set(name, value);
+  }
+  return map;
+}
+function extractBody(payload) {
+  if (payload === undefined)
+    return;
+  const mimeType = asString(payload.mimeType);
+  const data = asString(asRecord2(payload.body)?.data);
+  if (mimeType === "text/plain" && data !== undefined)
+    return decodeBase64Url(data);
+  const collected = [];
+  for (const raw of asArray(payload.parts)) {
+    const part = asRecord2(raw);
+    const text = extractBody(part);
+    if (text !== undefined && text.length > 0)
+      collected.push(text);
+  }
+  if (collected.length > 0)
+    return collected.join(`
+`);
+  return data !== undefined ? decodeBase64Url(data) : undefined;
+}
+function decodeBase64Url(data) {
+  try {
+    return Buffer.from(data, "base64url").toString("utf8");
+  } catch {
+    return "";
+  }
+}
+var DEFAULT_BASE_URL4 = "https://gmail.googleapis.com/gmail/v1", DEFAULT_TOKEN_ENV4 = "GMAIL_ACCESS_TOKEN", DEFAULT_MAX_PAGES4 = 10, DEFAULT_MAX_DOCUMENTS6 = 500, MAX_BODY_CHARS2 = 50000;
+var init_connector5 = () => {};
+
+// src/datasource/skills/gmail/skill.ts
+var GMAIL_SKILL_DEFINITION, GmailSkill;
+var init_skill4 = __esm(() => {
+  init_connector_skill();
+  init_connector5();
+  GMAIL_SKILL_DEFINITION = {
+    skillName: "gmail",
+    skillType: "gmail-account",
+    description: "Gmail datasource",
+    capabilities: ["email", "api", "polling"],
+    defaultTags: ["gmail", "email", "pii"],
+    contentType: "email",
+    manifestDescription: "Search indexed Gmail messages from the authorized account and labels. Use for questions about email conversations, decisions, or attachments discussed over email.",
+    manifestNotes: ["Label and folder visibility is bounded by the server-configured OAuth token."]
+  };
+  GmailSkill = class GmailSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(GMAIL_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new GmailConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/gmail/index.ts
+var init_gmail = __esm(() => {
+  init_connector5();
+  init_himalaya_connector();
+  init_skill4();
+});
+
+// src/datasource/skills/mail-export/connector.ts
+import { readdir, readFile as readFile4, stat as stat2 } from "node:fs/promises";
+import { basename as basename6, dirname as dirname11, extname as extname7, join as join18 } from "node:path";
+import { simpleParser as simpleParser2 } from "mailparser";
+
+class MailExportConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch() {
+    const paths = this.options.paths ?? [];
+    if (paths.length === 0)
+      return { ok: false, reason: "not-configured", message: "no mail export paths configured" };
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS7;
+    const maxBytes = this.options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE2;
+    const files = [];
+    let missingPaths = 0;
+    for (const path of paths) {
+      try {
+        const info = await stat2(path);
+        if (info.isDirectory()) {
+          const entries = await readdir(path, { recursive: true, withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isFile())
+              continue;
+            const extension = extname7(entry.name).toLowerCase();
+            if (extension === ".eml" || extension === ".mbox") {
+              files.push(join18(entry.parentPath, entry.name));
+            }
+          }
+        } else if (info.isFile()) {
+          files.push(path);
+        }
+      } catch {
+        missingPaths += 1;
+      }
+    }
+    if (missingPaths === paths.length) {
+      return { ok: false, reason: "unavailable", message: "no configured mail export paths were readable" };
+    }
+    const documents = [];
+    const warnings = [];
+    if (missingPaths > 0)
+      warnings.push(`${missingPaths} configured path(s) were unreadable`);
+    let parseFailures = 0;
+    let skippedLarge = 0;
+    for (const file of files.sort()) {
+      if (documents.length >= maxDocuments)
+        break;
+      let bytes;
+      try {
+        const info = await stat2(file);
+        if (info.size > maxBytes) {
+          skippedLarge += 1;
+          continue;
+        }
+        bytes = await readFile4(file);
+      } catch {
+        parseFailures += 1;
+        continue;
+      }
+      const stem = basename6(file, extname7(file));
+      const mailboxDir = basename6(dirname11(file));
+      const hierarchy = ["mailboxes", mailboxDir, stem];
+      const extension = extname7(file).toLowerCase();
+      const rawMessages = extension === ".mbox" ? splitMbox(bytes.toString("utf8")) : [bytes.toString("utf8")];
+      for (const [index, raw] of rawMessages.entries()) {
+        if (documents.length >= maxDocuments)
+          break;
+        try {
+          const parsed = await simpleParser2(raw);
+          const subject = parsed.subject ?? "(no subject)";
+          const from = Array.isArray(parsed.from) ? parsed.from[0]?.text : parsed.from?.text;
+          const to = Array.isArray(parsed.to) ? parsed.to[0]?.text : parsed.to?.text;
+          const body = (parsed.text ?? "").trim().slice(0, MAX_BODY_CHARS3);
+          const headerBlock = [
+            `Subject: ${subject}`,
+            ...from !== undefined ? [`From: ${from}`] : [],
+            ...to !== undefined ? [`To: ${to}`] : [],
+            ...parsed.date !== undefined ? [`Date: ${parsed.date.toISOString()}`] : []
+          ].join(`
+`);
+          const content = `${headerBlock}
+
+${body}`.trim();
+          if (content.length === 0)
+            continue;
+          documents.push({
+            docId: extension === ".mbox" ? `${stem}-${index + 1}` : stem,
+            hierarchy,
+            title: subject,
+            content,
+            ...parsed.date !== undefined ? { publishedAt: parsed.date.getTime() } : {},
+            metadata: {
+              path: file,
+              subject,
+              ...from !== undefined ? { from } : {},
+              messageIndex: index
+            }
+          });
+        } catch {
+          parseFailures += 1;
+        }
+      }
+    }
+    if (skippedLarge > 0)
+      warnings.push(`${skippedLarge} file(s) exceeded the size limit and were skipped`);
+    if (parseFailures > 0)
+      warnings.push(`${parseFailures} message(s) failed to parse`);
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+function splitMbox(text) {
+  const lines = text.split(/\r?\n/u);
+  const messages = [];
+  let current = [];
+  for (const line of lines) {
+    if (MBOX_SEPARATOR.test(line) && line.startsWith("From ")) {
+      if (current.length > 0)
+        messages.push(current.join(`
+`));
+      current = [];
+      continue;
+    }
+    current.push(line);
+  }
+  if (current.length > 0)
+    messages.push(current.join(`
+`));
+  return messages.filter((message) => message.trim().length > 0);
+}
+var DEFAULT_MAX_DOCUMENTS7 = 500, DEFAULT_MAX_BYTES_PER_FILE2, MAX_BODY_CHARS3 = 50000, MBOX_SEPARATOR;
+var init_connector6 = __esm(() => {
+  DEFAULT_MAX_BYTES_PER_FILE2 = 50 * 1024 * 1024;
+  MBOX_SEPARATOR = /^From .*\d{4}$/mu;
+});
+
+// src/datasource/skills/mail-export/skill.ts
+var MAIL_EXPORT_SKILL_DEFINITION, MailExportSkill;
+var init_skill5 = __esm(() => {
+  init_connector_skill();
+  init_connector6();
+  MAIL_EXPORT_SKILL_DEFINITION = {
+    skillName: "mail-export",
+    skillType: "mail-export",
+    description: "Local mail export datasource",
+    capabilities: ["email", "filesystem"],
+    defaultTags: ["mail-export", "email", "pii"],
+    contentType: "email",
+    manifestDescription: "Search indexed local mail exports (mbox/eml archives). Use for questions about archived email conversations.",
+    manifestNotes: [
+      "Only the server-configured export paths are indexed; archives are read locally and never uploaded."
+    ]
+  };
+  MailExportSkill = class MailExportSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(MAIL_EXPORT_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new MailExportConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/mail-export/index.ts
+var init_mail_export = __esm(() => {
+  init_connector6();
+  init_skill5();
+});
+
+// src/datasource/skills/notion/connector.ts
+class NotionConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV5);
+    if (token === undefined)
+      return { ok: false, reason: "not-configured", message: "auth token not configured" };
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL5;
+    const request = {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Notion-Version": NOTION_VERSION,
+        "Content-Type": "application/json"
+      },
+      timeoutMs: this.options.timeoutMs,
+      fetchImpl: this.options.fetchImpl,
+      signal
+    };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES5;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS8;
+    const entries = [];
+    let cursor;
+    for (let page = 0;page < maxPages; page += 1) {
+      const body = JSON.stringify({ page_size: 100, ...cursor !== undefined ? { start_cursor: cursor } : {} });
+      const result = await httpJson(`${baseUrl}/search`, { ...request, method: "POST", body });
+      if (!result.ok)
+        return { ok: false, reason: result.reason, message: `search failed: ${result.message}` };
+      const envelope = asRecord2(result.json);
+      if (envelope === undefined)
+        return { ok: false, reason: "invalid-data", message: "search response malformed" };
+      for (const raw of asArray(envelope.results)) {
+        const entry = asRecord2(raw);
+        if (entry !== undefined)
+          entries.push(entry);
+      }
+      cursor = envelope.has_more === true ? asString(envelope.next_cursor) : undefined;
+      if (cursor === undefined)
+        break;
+    }
+    const documents = [];
+    const warnings = [];
+    for (const entry of entries) {
+      if (documents.length >= maxDocuments)
+        break;
+      const id = asString(entry.id);
+      if (id === undefined)
+        continue;
+      const objectType = asString(entry.object) ?? "page";
+      const title = extractTitle(entry);
+      let blockText = "";
+      if (objectType === "page") {
+        const blocksResult = await httpJson(`${baseUrl}/blocks/${id}/children?page_size=100`, request);
+        if (blocksResult.ok) {
+          blockText = extractBlockText(blocksResult.json);
+        } else {
+          warnings.push(`page content fetch failed: ${blocksResult.message}`);
+        }
+      }
+      const content = [title, blockText].filter((part) => part.length > 0).join(`
+
+`);
+      if (content.length === 0)
+        continue;
+      documents.push({
+        docId: id,
+        hierarchy: hierarchyFor(entry, objectType),
+        ...title.length > 0 ? { title } : {},
+        content,
+        publishedAt: parseEpochMs(entry.last_edited_time),
+        metadata: {
+          objectType,
+          ...asString(entry.last_edited_time) !== undefined ? { lastEditedTime: asString(entry.last_edited_time) } : {}
+        }
+      });
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+function hierarchyFor(entry, objectType) {
+  if (objectType === "database")
+    return ["databases", asString(entry.id) ?? "unknown"];
+  const parent = asRecord2(entry.parent);
+  const parentType = asString(parent?.type);
+  if (parentType === "database_id") {
+    return ["databases", asString(parent?.database_id) ?? "unknown"];
+  }
+  if (parentType === "page_id") {
+    return ["pages", asString(parent?.page_id) ?? "unknown"];
+  }
+  return ["pages"];
+}
+function extractTitle(entry) {
+  const directTitle = plainText(entry.title);
+  if (directTitle.length > 0)
+    return directTitle;
+  const properties = asRecord2(entry.properties);
+  if (properties === undefined)
+    return "";
+  for (const value of Object.values(properties)) {
+    const property = asRecord2(value);
+    if (property === undefined || property.type !== "title")
+      continue;
+    const text = plainText(property.title);
+    if (text.length > 0)
+      return text;
+  }
+  return "";
+}
+function extractBlockText(json) {
+  const envelope = asRecord2(json);
+  const lines = [];
+  for (const raw of asArray(envelope?.results)) {
+    const block = asRecord2(raw);
+    const type = asString(block?.type);
+    if (block === undefined || type === undefined)
+      continue;
+    if (!TEXT_BLOCK_TYPES.includes(type))
+      continue;
+    const payload = asRecord2(block[type]);
+    const text = plainText(payload?.rich_text);
+    if (text.length > 0)
+      lines.push(text);
+  }
+  return lines.join(`
+`);
+}
+function plainText(richText) {
+  return asArray(richText).map((raw) => asString(asRecord2(raw)?.plain_text) ?? "").filter((text) => text.length > 0).join("").trim();
+}
+var DEFAULT_BASE_URL5 = "https://api.notion.com/v1", DEFAULT_TOKEN_ENV5 = "NOTION_TOKEN", NOTION_VERSION = "2022-06-28", DEFAULT_MAX_PAGES5 = 10, DEFAULT_MAX_DOCUMENTS8 = 500, TEXT_BLOCK_TYPES;
+var init_connector7 = __esm(() => {
+  TEXT_BLOCK_TYPES = [
+    "paragraph",
+    "heading_1",
+    "heading_2",
+    "heading_3",
+    "bulleted_list_item",
+    "numbered_list_item",
+    "to_do",
+    "quote",
+    "callout",
+    "code"
+  ];
+});
+
+// src/datasource/skills/notion/skill.ts
+var NOTION_SKILL_DEFINITION, NotionSkill;
+var init_skill6 = __esm(() => {
+  init_connector_skill();
+  init_connector7();
+  NOTION_SKILL_DEFINITION = {
+    skillName: "notion",
+    skillType: "notion-workspace",
+    description: "Notion workspace datasource",
+    capabilities: ["documents", "api", "polling"],
+    defaultTags: ["notion", "documents"],
+    contentType: "document",
+    manifestDescription: "Search indexed Notion pages and databases shared with the integration. Use for questions about Notion docs, wikis, and database entries.",
+    manifestNotes: ["Only pages shared with the server-configured integration token are indexed."]
+  };
+  NotionSkill = class NotionSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(NOTION_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new NotionConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/notion/index.ts
+var init_notion = __esm(() => {
+  init_connector7();
+  init_skill6();
+});
+
+// src/datasource/skills/obsidian/connector.ts
+import { readdir as readdir2, readFile as readFile5, stat as stat3 } from "node:fs/promises";
+import { basename as basename7, extname as extname8, join as join19, relative as relative5, sep as sep4 } from "node:path";
+
+class ObsidianConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch() {
+    const vaultPath = this.options.vaultPath;
+    if (vaultPath === undefined || vaultPath.length === 0) {
+      return { ok: false, reason: "not-configured", message: "vault path not configured" };
+    }
+    try {
+      const info = await stat3(vaultPath);
+      if (!info.isDirectory())
+        return { ok: false, reason: "unavailable", message: "vault path is not a directory" };
+    } catch {
+      return { ok: false, reason: "unavailable", message: "vault path is not readable" };
+    }
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS9;
+    const maxBytes = this.options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE3;
+    const files = [];
+    const walk = async (dir) => {
+      let entries;
+      try {
+        entries = await readdir2(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (!SKIPPED_DIRS.has(entry.name))
+            await walk(join19(dir, entry.name));
+        } else if (entry.isFile() && extname8(entry.name).toLowerCase() === ".md") {
+          files.push(join19(dir, entry.name));
+        }
+      }
+    };
+    await walk(vaultPath);
+    const documents = [];
+    let readFailures = 0;
+    let skippedLarge = 0;
+    for (const file of files.sort()) {
+      if (documents.length >= maxDocuments)
+        break;
+      let text;
+      try {
+        const info = await stat3(file);
+        if (info.size > maxBytes) {
+          skippedLarge += 1;
+          continue;
+        }
+        text = await readFile5(file, "utf8");
+        const relativePath = relative5(vaultPath, file);
+        const segments = relativePath.split(sep4);
+        const directorySegments = segments.slice(0, -1);
+        const stem = basename7(file, ".md");
+        const { body, frontmatterTags } = stripFrontmatter(text);
+        const inlineTags = matchAll(body, INLINE_TAG_PATTERN, 1);
+        const links = [];
+        const embeds = [];
+        for (const match of body.matchAll(WIKI_LINK_PATTERN)) {
+          const target = match[2]?.trim();
+          if (target === undefined || target.length === 0)
+            continue;
+          (match[1] === "!" ? embeds : links).push(target);
+        }
+        const heading = /^#\s+(.+)$/mu.exec(body)?.[1]?.trim();
+        const content = body.trim().slice(0, MAX_CONTENT_CHARS3);
+        if (content.length === 0)
+          continue;
+        documents.push({
+          docId: relativePath.split(sep4).join("__").replace(/\.md$/u, ""),
+          hierarchy: ["folders", ...directorySegments],
+          title: heading ?? stem,
+          content,
+          publishedAt: info.mtimeMs,
+          metadata: {
+            path: file,
+            tags: [...new Set([...frontmatterTags, ...inlineTags])],
+            links,
+            embeds,
+            folder: directorySegments.join("/")
+          }
+        });
+      } catch {
+        readFailures += 1;
+      }
+    }
+    const warnings = [];
+    if (skippedLarge > 0)
+      warnings.push(`${skippedLarge} note(s) exceeded the size limit and were skipped`);
+    if (readFailures > 0)
+      warnings.push(`${readFailures} note(s) failed to read`);
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+function stripFrontmatter(text) {
+  if (!text.startsWith("---"))
+    return { body: text, frontmatterTags: [] };
+  const end = text.indexOf(`
+---`, 3);
+  if (end === -1)
+    return { body: text, frontmatterTags: [] };
+  const frontmatter = text.slice(3, end);
+  const body = text.slice(text.indexOf(`
+`, end + 1) + 1);
+  return { body, frontmatterTags: parseFrontmatterTags(frontmatter) };
+}
+function parseFrontmatterTags(frontmatter) {
+  const lines = frontmatter.split(`
+`);
+  const tags = [];
+  for (const [index, line] of lines.entries()) {
+    const match = /^tags:\s*(.*)$/u.exec(line.trim());
+    if (match === null)
+      continue;
+    const inline = match[1]?.trim() ?? "";
+    if (inline.length > 0) {
+      const cleaned = inline.replace(/^\[/u, "").replace(/\]$/u, "");
+      for (const tag of cleaned.split(/[\s,]+/u)) {
+        const trimmed = tag.trim().replace(/^["'#]+|["']+$/gu, "");
+        if (trimmed.length > 0)
+          tags.push(trimmed);
+      }
+      break;
+    }
+    for (let cursor = index + 1;cursor < lines.length; cursor += 1) {
+      const item = /^\s*-\s*(.+)$/u.exec(lines[cursor] ?? "");
+      if (item === null)
+        break;
+      const trimmed = item[1]?.trim().replace(/^["'#]+|["']+$/gu, "") ?? "";
+      if (trimmed.length > 0)
+        tags.push(trimmed);
+    }
+    break;
+  }
+  return tags;
+}
+function matchAll(text, pattern, group) {
+  const out = [];
+  for (const match of text.matchAll(pattern)) {
+    const value = match[group]?.trim();
+    if (value !== undefined && value.length > 0)
+      out.push(value);
+  }
+  return out;
+}
+var DEFAULT_MAX_DOCUMENTS9 = 1000, DEFAULT_MAX_BYTES_PER_FILE3, MAX_CONTENT_CHARS3 = 1e5, SKIPPED_DIRS, INLINE_TAG_PATTERN, WIKI_LINK_PATTERN;
+var init_connector8 = __esm(() => {
+  DEFAULT_MAX_BYTES_PER_FILE3 = 2 * 1024 * 1024;
+  SKIPPED_DIRS = new Set([".obsidian", ".trash", ".git", "node_modules"]);
+  INLINE_TAG_PATTERN = /(?:^|\s)#([A-Za-z0-9_/-]+)/gu;
+  WIKI_LINK_PATTERN = /(!?)\[\[([^\]|]+)(?:\|[^\]]*)?\]\]/gu;
+});
+
+// src/datasource/skills/obsidian/skill.ts
+var OBSIDIAN_SKILL_DEFINITION, ObsidianSkill;
+var init_skill7 = __esm(() => {
+  init_connector_skill();
+  init_connector8();
+  OBSIDIAN_SKILL_DEFINITION = {
+    skillName: "obsidian",
+    skillType: "obsidian-vault",
+    description: "Obsidian vault datasource",
+    capabilities: ["notes", "filesystem"],
+    defaultTags: ["obsidian", "notes"],
+    contentType: "note",
+    manifestDescription: "Search indexed Obsidian vault notes, including tags, wiki links, and embeds. Use for questions about personal notes and knowledge-base content.",
+    manifestNotes: ["Only the server-configured vault is indexed; note metadata includes tags, links, and embeds."]
+  };
+  ObsidianSkill = class ObsidianSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(OBSIDIAN_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new ObsidianConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/obsidian/index.ts
+var init_obsidian = __esm(() => {
+  init_connector8();
+  init_skill7();
+});
+
+// src/datasource/skills/rss/connector.ts
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
+
+class RssConnector {
+  options;
+  parser = new XMLParser2({ ignoreAttributes: false });
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const feeds = this.options.feeds ?? [];
+    if (feeds.length === 0)
+      return { ok: false, reason: "not-configured", message: "no feeds configured" };
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS10;
+    const maxItemsPerFeed = this.options.maxItemsPerFeed ?? DEFAULT_MAX_ITEMS_PER_FEED;
+    const documents = [];
+    const warnings = [];
+    let failedFeeds = 0;
+    for (const [index, feed] of feeds.entries()) {
+      if (documents.length >= maxDocuments)
+        break;
+      const result = await httpText(feed.url, {
+        headers: { Accept: ACCEPT_HEADER },
+        timeoutMs: this.options.timeoutMs ?? DEFAULT_FEED_TIMEOUT_MS,
+        fetchImpl: this.options.fetchImpl,
+        signal
+      });
+      if (!result.ok) {
+        failedFeeds += 1;
+        warnings.push(`feed ${index + 1} failed: ${result.message}`);
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = this.parser.parse(result.text);
+      } catch {
+        failedFeeds += 1;
+        warnings.push(`feed ${index + 1} failed: unparseable XML`);
+        continue;
+      }
+      const normalized = normalizeFeed(parsed);
+      if (normalized === undefined) {
+        failedFeeds += 1;
+        warnings.push(`feed ${index + 1} failed: unrecognized feed shape`);
+        continue;
+      }
+      const feedTitle = normalized.title ?? `feed-${index + 1}`;
+      const hierarchy = feed.category !== undefined ? ["feeds", feed.category, feedTitle] : ["feeds", feedTitle];
+      for (const item of normalized.items.slice(0, maxItemsPerFeed)) {
+        if (documents.length >= maxDocuments)
+          break;
+        const title = item.title ?? "(untitled)";
+        const body = stripHtml(item.body ?? "");
+        const content = body.length > 0 ? `${title}
+
+${body}` : title;
+        documents.push({
+          docId: item.id,
+          hierarchy,
+          title,
+          content: content.slice(0, MAX_CONTENT_CHARS4),
+          ...item.publishedAt !== undefined ? { publishedAt: item.publishedAt } : {},
+          metadata: { feedIndex: index, feedTitle, categories: item.categories }
+        });
+      }
+    }
+    if (failedFeeds === feeds.length) {
+      return { ok: false, reason: "unavailable", message: "all configured feeds failed" };
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+function normalizeFeed(parsed) {
+  const root = asRecord2(parsed);
+  if (root === undefined)
+    return;
+  const channel = asRecord2(asRecord2(root.rss)?.channel);
+  if (channel !== undefined) {
+    const items = asArray(channel.item ?? []).concat(asRecord2(channel.item) !== undefined ? [channel.item] : []);
+    return { title: textOf(channel.title), items: items.map(normalizeRssItem).filter(present) };
+  }
+  const atom = asRecord2(root.feed);
+  if (atom !== undefined) {
+    const entries = asArray(atom.entry ?? []).concat(asRecord2(atom.entry) !== undefined ? [atom.entry] : []);
+    return { title: textOf(atom.title), items: entries.map(normalizeAtomEntry).filter(present) };
+  }
+  return;
+}
+function normalizeRssItem(raw) {
+  const item = asRecord2(raw);
+  if (item === undefined)
+    return;
+  const title = textOf(item.title);
+  const guid = textOf(item.guid) ?? textOf(item.link) ?? title;
+  if (guid === undefined)
+    return;
+  return {
+    id: guid,
+    title,
+    body: textOf(item.description),
+    publishedAt: parseEpochMs(textOf(item.pubDate)),
+    categories: categoriesOf(item.category)
+  };
+}
+function normalizeAtomEntry(raw) {
+  const entry = asRecord2(raw);
+  if (entry === undefined)
+    return;
+  const title = textOf(entry.title);
+  const id = textOf(entry.id) ?? title;
+  if (id === undefined)
+    return;
+  return {
+    id,
+    title,
+    body: textOf(entry.summary) ?? textOf(entry.content),
+    publishedAt: parseEpochMs(textOf(entry.published) ?? textOf(entry.updated)),
+    categories: categoriesOf(entry.category)
+  };
+}
+function textOf(value) {
+  const direct = asString(value);
+  if (direct !== undefined)
+    return direct.trim();
+  if (typeof value === "number")
+    return String(value);
+  const record = asRecord2(value);
+  if (record !== undefined) {
+    const text = asString(record["#text"]) ?? asString(record["@_term"]);
+    if (text !== undefined)
+      return text.trim();
+    if (typeof record["#text"] === "number")
+      return String(record["#text"]);
+  }
+  return;
+}
+function categoriesOf(value) {
+  const values = Array.isArray(value) ? value : value !== undefined ? [value] : [];
+  return values.map(textOf).filter((category) => category !== undefined && category.length > 0);
+}
+function stripHtml(text) {
+  return text.replace(/<[^>]+>/gu, " ").replace(/\s+/gu, " ").trim();
+}
+function present(item) {
+  return item !== undefined;
+}
+var DEFAULT_MAX_DOCUMENTS10 = 500, DEFAULT_MAX_ITEMS_PER_FEED = 100, DEFAULT_FEED_TIMEOUT_MS = 30000, MAX_CONTENT_CHARS4 = 20000, ACCEPT_HEADER = "application/rss+xml, application/atom+xml, application/xml, text/xml";
+var init_connector9 = () => {};
+
+// src/datasource/skills/rss/skill.ts
+var RSS_SKILL_DEFINITION, DEFAULT_DEDUPE_WINDOW_MS, RssSkill;
+var init_skill8 = __esm(() => {
+  init_connector_skill();
+  init_connector9();
+  RSS_SKILL_DEFINITION = {
+    skillName: "rss",
+    skillType: "rss-feeds",
+    description: "RSS/news datasource",
+    capabilities: ["news", "api", "polling"],
+    defaultTags: ["rss", "news", "public"],
+    contentType: "article",
+    manifestDescription: "Search indexed RSS/news feed articles from the configured feeds. Use for questions about recent news items or blog posts the server subscribes to.",
+    manifestNotes: ["Feeds are polled with a dedupe window so re-delivered items are indexed once per window."]
+  };
+  DEFAULT_DEDUPE_WINDOW_MS = 24 * 60 * 60 * 1000;
+  RssSkill = class RssSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(RSS_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new RssConnector(connectorOptions ?? {}),
+        dedupeWindowMs: options.dedupeWindowMs ?? DEFAULT_DEDUPE_WINDOW_MS
+      });
+    }
+  };
+});
+
+// src/datasource/skills/rss/index.ts
+var init_rss = __esm(() => {
+  init_connector9();
+  init_skill8();
+});
+
+// src/datasource/skills/slack/connector.ts
+class SlackConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV6);
+    if (token === undefined)
+      return { ok: false, reason: "not-configured", message: "auth token not configured" };
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL6;
+    const headers = { Authorization: `Bearer ${token}` };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES6;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS11;
+    const request = { headers, timeoutMs: this.options.timeoutMs, fetchImpl: this.options.fetchImpl, signal };
+    const channels = [];
+    let cursor;
+    for (let page = 0;page < maxPages; page += 1) {
+      const url = new URL(`${baseUrl}/conversations.list`);
+      url.searchParams.set("limit", "200");
+      url.searchParams.set("types", "public_channel,private_channel");
+      if (cursor !== undefined)
+        url.searchParams.set("cursor", cursor);
+      const result = await httpJson(url.toString(), request);
+      if (!result.ok)
+        return { ok: false, reason: result.reason, message: `channel list failed: ${result.message}` };
+      const envelope = asRecord2(result.json);
+      if (envelope === undefined)
+        return { ok: false, reason: "invalid-data", message: "channel list malformed" };
+      if (envelope.ok !== true) {
+        const error = asString(envelope.error) ?? "unknown-error";
+        if (AUTH_ERRORS.has(error))
+          return { ok: false, reason: "auth", message: `slack: ${error}` };
+        if (error === "ratelimited")
+          return { ok: false, reason: "rate-limited", message: "slack: ratelimited" };
+        return { ok: false, reason: "api-error", message: `slack: ${error}` };
+      }
+      for (const raw of asArray(envelope.channels)) {
+        const channel = asRecord2(raw);
+        const id = asString(channel?.id);
+        const name = asString(channel?.name);
+        if (id !== undefined && name !== undefined)
+          channels.push({ id, name });
+      }
+      cursor = asString(asRecord2(envelope.response_metadata)?.next_cursor);
+      if (cursor === undefined || cursor.length === 0)
+        break;
+    }
+    const filter = this.options.channels;
+    const selected = filter === undefined || filter.length === 0 ? channels : channels.filter((channel) => filter.includes(channel.id) || filter.includes(channel.name));
+    const documents = [];
+    const warnings = [];
+    for (const channel of selected) {
+      if (documents.length >= maxDocuments)
+        break;
+      let historyCursor;
+      for (let page = 0;page < maxPages && documents.length < maxDocuments; page += 1) {
+        const url = new URL(`${baseUrl}/conversations.history`);
+        url.searchParams.set("channel", channel.id);
+        url.searchParams.set("limit", "200");
+        if (historyCursor !== undefined)
+          url.searchParams.set("cursor", historyCursor);
+        const result = await httpJson(url.toString(), request);
+        if (!result.ok) {
+          warnings.push(`channel ${channel.name} history failed: ${result.message}`);
+          break;
+        }
+        const envelope = asRecord2(result.json);
+        if (envelope === undefined || envelope.ok !== true) {
+          const error = asString(envelope?.error) ?? "malformed response";
+          if (AUTH_ERRORS.has(error))
+            return { ok: false, reason: "auth", message: `slack: ${error}` };
+          if (error === "ratelimited")
+            return { ok: false, reason: "rate-limited", message: "slack: ratelimited" };
+          if (CHANNEL_SKIP_ERRORS.has(error))
+            warnings.push(`channel ${channel.name} skipped: ${error}`);
+          else
+            warnings.push(`channel ${channel.name} history failed: ${error}`);
+          break;
+        }
+        for (const raw of asArray(envelope.messages)) {
+          if (documents.length >= maxDocuments)
+            break;
+          const message = asRecord2(raw);
+          if (message === undefined)
+            continue;
+          const text = asString(message.text);
+          const ts = asString(message.ts);
+          const subtype = asString(message.subtype);
+          if (text === undefined || text.length === 0 || ts === undefined)
+            continue;
+          if (subtype === "channel_join")
+            continue;
+          const user = asString(message.user) ?? asString(message.username) ?? "unknown";
+          documents.push({
+            docId: `${channel.id}-${ts.replace(/\./gu, "-")}`,
+            hierarchy: ["channels", channel.name],
+            title: `#${channel.name}`,
+            content: `${user}: ${text}`,
+            publishedAt: Math.round(Number.parseFloat(ts) * 1000),
+            metadata: { channelId: channel.id, ts, user }
+          });
+        }
+        historyCursor = asString(asRecord2(envelope.response_metadata)?.next_cursor);
+        if (historyCursor === undefined || historyCursor.length === 0)
+          break;
+      }
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+var DEFAULT_BASE_URL6 = "https://slack.com/api", DEFAULT_TOKEN_ENV6 = "SLACK_BOT_TOKEN", DEFAULT_MAX_PAGES6 = 10, DEFAULT_MAX_DOCUMENTS11 = 500, AUTH_ERRORS, CHANNEL_SKIP_ERRORS;
+var init_connector10 = __esm(() => {
+  AUTH_ERRORS = new Set(["invalid_auth", "not_authed", "token_revoked", "account_inactive"]);
+  CHANNEL_SKIP_ERRORS = new Set(["missing_scope", "access_denied", "channel_not_found", "not_in_channel"]);
+});
+
+// src/datasource/skills/slack/skill.ts
+var SLACK_SKILL_DEFINITION, SlackSkill;
+var init_skill9 = __esm(() => {
+  init_connector_skill();
+  init_connector10();
+  SLACK_SKILL_DEFINITION = {
+    skillName: "slack",
+    skillType: "slack-workspace",
+    description: "Slack workspace datasource",
+    capabilities: ["chat", "api", "polling"],
+    defaultTags: ["slack", "chat", "pii"],
+    contentType: "chat",
+    manifestDescription: "Search indexed Slack messages across authorized workspace channels. Use for questions about Slack conversations, decisions made in channels, or who said what.",
+    manifestNotes: [
+      "Message history windows and channel visibility are bounded by the server-configured bot token scopes."
+    ]
+  };
+  SlackSkill = class SlackSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(SLACK_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new SlackConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/slack/index.ts
+var init_slack = __esm(() => {
+  init_connector10();
+  init_skill9();
+});
+
+// src/datasource/skills/spotlight/connector.ts
+import { spawn as spawn7 } from "node:child_process";
+import { createHash as createHash8 } from "node:crypto";
+import { readFile as fsReadFile, stat as stat4 } from "node:fs/promises";
+import { basename as basename8, extname as extname9 } from "node:path";
+
+class SpotlightConnector {
+  options;
+  run;
+  readFile;
+  platform;
+  constructor(options = {}) {
+    this.options = options;
+    this.run = options.run ?? spawnRunner;
+    this.readFile = options.readFile ?? ((path) => fsReadFile(path, "utf8"));
+    this.platform = options.platform ?? process.platform;
+  }
+  async fetch() {
+    if (this.platform !== "darwin") {
+      return { ok: false, reason: "unavailable", message: "spotlight datasource is supported on macOS only" };
+    }
+    const queries = (this.options.queries ?? []).map((query) => query.trim()).filter((query) => query.length > 0);
+    if (queries.length === 0) {
+      return { ok: false, reason: "not-configured", message: "no spotlight queries configured" };
+    }
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
+    const status = await this.run("mdutil", ["-s", "/"], timeoutMs);
+    if (status.ok && /indexing disabled/iu.test(status.stdout)) {
+      return {
+        ok: false,
+        reason: "unavailable",
+        message: "Spotlight indexing is disabled; enable it with `sudo mdutil -i on /`"
+      };
+    }
+    const maxPerQuery = this.options.maxResultsPerQuery ?? DEFAULT_MAX_RESULTS_PER_QUERY;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS12;
+    const seen = new Set;
+    const paths = [];
+    let mdfindMissing = false;
+    let failedQueries = 0;
+    for (const query of queries) {
+      const args = this.options.onlyIn !== undefined ? ["-onlyin", this.options.onlyIn, query] : [query];
+      const result = await this.run("mdfind", args, timeoutMs);
+      if (!result.ok) {
+        if (result.error === "ENOENT") {
+          mdfindMissing = true;
+          break;
+        }
+        failedQueries += 1;
+        continue;
+      }
+      let kept = 0;
+      for (const line of result.stdout.split(`
+`)) {
+        const path = line.trim();
+        if (path.length === 0 || seen.has(path))
+          continue;
+        if (kept >= maxPerQuery)
+          break;
+        seen.add(path);
+        paths.push(path);
+        kept += 1;
+      }
+    }
+    if (mdfindMissing) {
+      return { ok: false, reason: "unavailable", message: "mdfind binary not found; Spotlight requires macOS" };
+    }
+    if (failedQueries === queries.length) {
+      return { ok: false, reason: "unavailable", message: "every configured mdfind query failed" };
+    }
+    const maxBytes = this.options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE4;
+    const documents = [];
+    let permissionDenied = 0;
+    let readFailures = 0;
+    for (const path of paths) {
+      if (documents.length >= maxDocuments)
+        break;
+      try {
+        const info = await stat4(path);
+        if (!info.isFile() || info.size > maxBytes)
+          continue;
+        const text = await this.readFile(path);
+        const content = text.trim().slice(0, MAX_CONTENT_CHARS5);
+        if (content.length === 0)
+          continue;
+        documents.push({
+          docId: createHash8("sha256").update(path).digest("hex").slice(0, 16),
+          hierarchy: ["files"],
+          title: basename8(path),
+          content,
+          publishedAt: info.mtimeMs,
+          metadata: { path, extension: extname9(path).toLowerCase() }
+        });
+      } catch (error) {
+        const code = error.code;
+        if (code === "EPERM" || code === "EACCES")
+          permissionDenied += 1;
+        else
+          readFailures += 1;
+      }
+    }
+    if (documents.length === 0 && permissionDenied > 0) {
+      return {
+        ok: false,
+        reason: "permission",
+        message: `macOS denied access to all Spotlight hits; ${FDA_GUIDANCE}`
+      };
+    }
+    const warnings = [];
+    if (failedQueries > 0)
+      warnings.push(`${failedQueries} mdfind quer(y/ies) failed`);
+    if (permissionDenied > 0) {
+      warnings.push(`${permissionDenied} Spotlight hit(s) were denied by macOS privacy protections; ${FDA_GUIDANCE}`);
+    }
+    if (readFailures > 0)
+      warnings.push(`${readFailures} Spotlight hit(s) failed to read`);
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
 }
-function datasourceSourceHasFragment(source) {
-  return typeof source === "string" && source.includes("#");
+var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS12 = 300, DEFAULT_MAX_BYTES_PER_FILE4, DEFAULT_TIMEOUT_MS6 = 15000, MAX_CONTENT_CHARS5 = 1e5, MAX_BUFFER_BYTES, FDA_GUIDANCE = "grant Full Disk Access to the terminal or app running AutoRAG (System Settings -> Privacy & Security -> Full Disk Access), then restart it", spawnRunner = (command, args, timeoutMs) => new Promise((resolve9) => {
+  const child = spawn7(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
+  let stdout = "";
+  let stderr = "";
+  let settled = false;
+  const finish = (result) => {
+    if (settled)
+      return;
+    settled = true;
+    clearTimeout(timer);
+    resolve9(result);
+  };
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    finish({ ok: false, stdout, stderr: "process timed out", code: null });
+  }, timeoutMs);
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    if (stdout.length < MAX_BUFFER_BYTES)
+      stdout += chunk;
+  });
+  child.stderr.on("data", (chunk) => {
+    if (stderr.length < MAX_BUFFER_BYTES)
+      stderr += chunk;
+  });
+  child.on("error", (error) => {
+    finish({ ok: false, stdout, stderr: error.message, code: null, error: error.code });
+  });
+  child.on("close", (code) => {
+    finish({ ok: code === 0, stdout, stderr, code });
+  });
+});
+var init_connector11 = __esm(() => {
+  DEFAULT_MAX_BYTES_PER_FILE4 = 256 * 1024;
+  MAX_BUFFER_BYTES = 4 * 1024 * 1024;
+});
+
+// src/datasource/skills/spotlight/skill.ts
+var SPOTLIGHT_SKILL_DEFINITION, SpotlightSkill;
+var init_skill10 = __esm(() => {
+  init_connector_skill();
+  init_connector11();
+  SPOTLIGHT_SKILL_DEFINITION = {
+    skillName: "spotlight",
+    skillType: "spotlight-search",
+    description: "macOS Spotlight datasource",
+    capabilities: ["files", "macos-only", "local-search"],
+    defaultTags: ["spotlight", "files"],
+    contentType: "document",
+    manifestDescription: "Search files indexed by macOS Spotlight via the built-in mdfind CLI. macOS only; no external installs. Use for questions about local documents on the Mac running AutoRAG.",
+    manifestNotes: [
+      "## Platform requirements",
+      "- macOS only: this datasource is unavailable on any other platform.",
+      "- Spotlight indexing must be enabled (`sudo mdutil -i on /`; check with `mdutil -s /`).",
+      "- **Full Disk Access**: Spotlight can find protected files (Mail, Messages, Safari data, parts of ~/Library), but reading their content fails unless the terminal or app running AutoRAG has Full Disk Access. Grant it under System Settings -> Privacy & Security -> Full Disk Access, add the host app (e.g. Terminal, iTerm, or the AutoRAG binary), then restart the app. Permission failures surface as `datasource-permission-denied`.",
+      "",
+      "## Operator cheat sheet",
+      "- `mdfind <query>` — Spotlight search; `mdfind -onlyin <dir> <query>` scopes to a directory; `mdfind -name <text>` matches file names.",
+      "- `mdls <file>` — show Spotlight metadata attributes (kMDItemDisplayName, kMDItemContentType, …) for one file.",
+      "- `mdutil -s /` — index status; `sudo mdutil -i on /` / `-i off /` — enable/disable indexing; `sudo mdutil -E /` — erase and rebuild the index.",
+      "",
+      "Queries are trusted server configuration; indexing re-runs the configured mdfind queries and hydrates text content. Result metadata carries the real absolute file path (`path`) so hits are traceable back to disk; if paths must not leave this machine, run AutoRAG with a local LLM."
+    ]
+  };
+  SpotlightSkill = class SpotlightSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(SPOTLIGHT_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new SpotlightConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/spotlight/index.ts
+var init_spotlight = __esm(() => {
+  init_connector11();
+  init_skill10();
+});
+
+// src/datasource/skills/factory.ts
+function common(config, workspaceRoot) {
+  return {
+    ...config.instanceId !== undefined ? { instanceId: config.instanceId } : {},
+    ...config.pollingIntervalMs !== undefined ? { pollingIntervalMs: config.pollingIntervalMs } : {},
+    ...config.tags !== undefined ? { tags: config.tags } : {},
+    ...workspaceRoot !== undefined ? { workspaceRoot } : {}
+  };
 }
-function isDatasourceSource(source) {
-  if (typeof source !== "string" || source.length === 0)
+function buildDatasourceSkills(config, workspaceRoot) {
+  const skills = [];
+  const unknown = [];
+  for (const [name, raw] of Object.entries(config ?? {})) {
+    if (raw === false)
+      continue;
+    const entry = raw === true ? {} : raw;
+    if (entry.enabled === false)
+      continue;
+    const builder = BUILDERS[name];
+    if (builder === undefined) {
+      unknown.push(name);
+      continue;
+    }
+    skills.push(builder(entry, workspaceRoot));
+  }
+  return { skills, unknown };
+}
+var BUILDERS, BUILTIN_DATASOURCE_SKILL_NAMES;
+var init_factory = __esm(() => {
+  init_discord();
+  init_gdrive();
+  init_rclone_connector();
+  init_github();
+  init_himalaya_connector();
+  init_gmail();
+  init_mail_export();
+  init_notion();
+  init_obsidian();
+  init_rss();
+  init_slack();
+  init_spotlight();
+  BUILDERS = {
+    slack: (config, workspaceRoot) => new SlackSkill({ ...common(config, workspaceRoot), connectorOptions: config.connector }),
+    discord: (config, workspaceRoot) => new DiscordSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    }),
+    notion: (config, workspaceRoot) => new NotionSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    }),
+    github: (config, workspaceRoot) => new GitHubSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    }),
+    gdrive: (config, workspaceRoot) => {
+      const connector = config.connector;
+      if (connector?.backend === "rclone") {
+        const { backend: _backend, ...rcloneOptions } = connector;
+        return new GDriveSkill({
+          ...common(config, workspaceRoot),
+          connector: new RcloneConnector(rcloneOptions)
+        });
+      }
+      return new GDriveSkill({
+        ...common(config, workspaceRoot),
+        connectorOptions: connector
+      });
+    },
+    gmail: (config, workspaceRoot) => {
+      const connector = config.connector;
+      if (connector?.backend === "himalaya") {
+        const { backend: _backend, ...himalayaOptions } = connector;
+        return new GmailSkill({
+          ...common(config, workspaceRoot),
+          connector: new HimalayaConnector(himalayaOptions)
+        });
+      }
+      return new GmailSkill({ ...common(config, workspaceRoot), connectorOptions: connector });
+    },
+    "mail-export": (config, workspaceRoot) => new MailExportSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    }),
+    obsidian: (config, workspaceRoot) => new ObsidianSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    }),
+    rss: (config, workspaceRoot) => new RssSkill({ ...common(config, workspaceRoot), connectorOptions: config.connector }),
+    spotlight: (config, workspaceRoot) => new SpotlightSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    })
+  };
+  BUILTIN_DATASOURCE_SKILL_NAMES = Object.keys(BUILDERS);
+});
+
+// src/index.ts
+init_agent();
+
+// src/agent/index.ts
+init_agent();
+init_datasource_skill();
+init_emit_results_tool();
+init_jikji_find_tool();
+init_search_all_tool();
+init_search_datasource_tool();
+init_search_minsync_tool();
+init_system_prompt();
+
+// src/index.ts
+init_system_prompt();
+
+// src/datasource/index.ts
+init_access_context();
+init_chunk_store();
+init_connector();
+init_connector_skill();
+
+// src/datasource/polling.ts
+function isDue(metadata, now, lastIndexedAt) {
+  if (metadata.mode !== "poll")
     return false;
-  if (datasourceSourceHasFragment(source))
+  const intervalMs = metadata.intervalMs;
+  if (intervalMs === undefined || intervalMs <= 0)
     return false;
-  const normalized = normalizeVirtualPath(source);
-  return normalized !== "/";
-}
-function matchesDatasourceScope(source, scope) {
-  if (datasourceSourceHasFragment(source))
+  const last = lastIndexedAt ?? metadata.lastIndexedAt;
+  if (last === undefined)
+    return true;
+  if (!Number.isFinite(now) || !Number.isFinite(last))
     return false;
-  return matchesVirtualPathScope(source, scope);
+  return now - last >= intervalMs;
+}
+function parseCronExpr(expr) {
+  if (typeof expr !== "string") {
+    return fail("cron expression must be a string");
+  }
+  const trimmed = expr.trim();
+  if (trimmed.length === 0) {
+    return fail("cron expression is empty");
+  }
+  const fields = trimmed.split(/\s+/u);
+  if (fields.length !== 5) {
+    return fail(`expected 5 fields, got ${fields.length}`);
+  }
+  const [minute, hour, dom, month, dow] = fields;
+  const errors = [];
+  validateField(minute, 0, 59, "minute", errors);
+  validateField(hour, 0, 23, "hour", errors);
+  validateField(dom, 1, 31, "day-of-month", errors);
+  validateField(month, 1, 12, "month", errors);
+  validateField(dow, 0, 7, "day-of-week", errors);
+  if (errors.length > 0) {
+    return fail(errors.join("; "));
+  }
+  return { ok: true, expr: trimmed };
+}
+function fail(error) {
+  return { ok: false, error };
+}
+function validateField(field, min, max, label, errors) {
+  const parts = field.split(",");
+  if (parts.length === 0) {
+    errors.push(`${label}: empty`);
+    return;
+  }
+  for (const part of parts) {
+    const err = validatePart(part, min, max, label);
+    if (err !== null)
+      errors.push(err);
+  }
+}
+function validatePart(part, min, max, label) {
+  if (part.length === 0)
+    return `${label}: empty term`;
+  const slashIndex = part.indexOf("/");
+  let base = part;
+  let stepText;
+  if (slashIndex >= 0) {
+    base = part.slice(0, slashIndex);
+    stepText = part.slice(slashIndex + 1);
+    const step = parseNumber(stepText);
+    if (step === null || step <= 0) {
+      return `${label}: invalid step "${stepText}"`;
+    }
+  }
+  if (base === "*")
+    return null;
+  if (base.includes("-")) {
+    const [loText, hiText] = base.split("-");
+    if (hiText === undefined || loText === undefined) {
+      return `${label}: malformed range "${base}"`;
+    }
+    const lo = parseNumber(loText);
+    const hi = parseNumber(hiText);
+    if (lo === null || hi === null) {
+      return `${label}: non-numeric range "${base}"`;
+    }
+    if (lo < min || lo > max || hi < min || hi > max) {
+      return `${label}: range "${base}" out of bounds (${min}-${max})`;
+    }
+    if (lo > hi) {
+      return `${label}: range "${base}" has low > high`;
+    }
+    return null;
+  }
+  const v = parseNumber(base);
+  if (v === null) {
+    return `${label}: invalid value "${base}"`;
+  }
+  if (v < min || v > max) {
+    return `${label}: value ${v} out of bounds (${min}-${max})`;
+  }
+  return null;
+}
+function parseNumber(text) {
+  if (!/^\d+$/u.test(text))
+    return null;
+  return Number.parseInt(text, 10);
 }
-
 // src/datasource/registry.ts
+init_scope();
+
 class DatasourceSkillRegistry {
   skills = new Map;
   register(skill) {
@@ -8597,16 +11664,25 @@ function safePolling(skill) {
     return;
   }
 }
+
+// src/datasource/index.ts
+init_scope();
+init_discord();
+init_factory();
+init_gdrive();
+init_github();
+init_gmail();
+
 // src/datasource/skills/katok/client.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 
 // src/datasource/skills/katok/paths.ts
-import { join as join17 } from "node:path";
+import { join as join20 } from "node:path";
 var AUTORAG_DIRNAME = ".autorag";
 var DATASOURCES_DIRNAME = "datasources";
 var KATOK_DATASOURCE_DIRNAME = "katok";
 function katokDatasourceRoot(workspaceRoot) {
-  return join17(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, KATOK_DATASOURCE_DIRNAME);
+  return join20(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, KATOK_DATASOURCE_DIRNAME);
 }
 
 // src/datasource/skills/katok/types.ts
@@ -8720,7 +11796,7 @@ class KatokClient {
 function spawnKatok(request) {
   return new Promise((resolve9) => {
     const { options, args, env, signal } = request;
-    const child = spawn5(commandFor2(options.binaryPath), args, {
+    const child = spawn8(commandFor2(options.binaryPath), args, {
       env,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -8871,22 +11947,22 @@ function parseJsonObject(stdout) {
     return;
   return parsed;
 }
-function asRecord2(value) {
+function asRecord3(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     return;
   return value;
 }
-function asString(value) {
+function asString2(value) {
   return typeof value === "string" ? value : undefined;
 }
-function asNumber(value) {
+function asNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 function asBoolean(value) {
   return typeof value === "boolean" ? value : undefined;
 }
 function normalizeDoctor(raw) {
-  const version = asString(raw.version);
+  const version = asString2(raw.version);
   const ready = asBoolean(raw.ready);
   if (ready === undefined)
     return;
@@ -8897,12 +11973,12 @@ function normalizeSync(raw) {
   const synced = asBoolean(raw.synced);
   if (synced === undefined)
     return;
-  const messageCount = asNumber(raw.messageCount);
+  const messageCount = asNumber2(raw.messageCount);
   const metadata = stripKnown(raw, new Set(["synced", "messageCount"]));
   return { synced, ...messageCount !== undefined ? { messageCount } : {}, metadata };
 }
 function normalizeIndex(raw) {
-  const chunkCount = asNumber(raw.chunkCount);
+  const chunkCount = asNumber2(raw.chunkCount);
   if (chunkCount === undefined)
     return;
   const metadata = stripKnown(raw, new Set(["chunkCount"]));
@@ -8914,12 +11990,12 @@ function normalizeHits(raw) {
     return;
   const normalized = [];
   for (const entry of hits) {
-    const record = asRecord2(entry);
+    const record = asRecord3(entry);
     if (record === undefined)
       return;
-    const chunkId = asString(record.chunkId);
-    const score = asNumber(record.score);
-    const content = asString(record.content);
+    const chunkId = asString2(record.chunkId);
+    const score = asNumber2(record.score);
+    const content = asString2(record.content);
     if (chunkId === undefined || chunkId.length === 0 || score === undefined || content === undefined)
       return;
     const metadata = stripKnown(record, new Set(["chunkId", "score", "content"]));
@@ -8928,8 +12004,8 @@ function normalizeHits(raw) {
   return normalized;
 }
 function normalizeChunk(raw) {
-  const chunkId = asString(raw.chunkId);
-  const content = asString(raw.content);
+  const chunkId = asString2(raw.chunkId);
+  const content = asString2(raw.content);
   if (chunkId === undefined || chunkId.length === 0 || content === undefined)
     return;
   const metadata = stripKnown(raw, new Set(["chunkId", "content"]));
@@ -8941,7 +12017,7 @@ function normalizeContext(raw) {
     return;
   const chunks = [];
   for (const entry of chunksValue) {
-    const record = asRecord2(entry);
+    const record = asRecord3(entry);
     if (record === undefined)
       return;
     const chunk = normalizeChunk(record);
@@ -8979,9 +12055,10 @@ function ok(data, result) {
   return { ok: true, data, stdout: result.stdout, stderr: result.stderr, code: result.code ?? 0 };
 }
 // src/datasource/skills/katok/methods.ts
+init_scope();
 var KAKAO_DATASOURCE_ID = "kakao";
 var DEFAULT_KAKAO_TAGS = ["kakaotalk", "personal", "pii"];
-var DEFAULT_TOP_K2 = 20;
+var DEFAULT_TOP_K3 = 20;
 
 class KatokBm25Method {
   client;
@@ -9036,7 +12113,7 @@ async function retrieveKatok(client, mode, methodName, instanceId, query, option
   const trimmed = query.trim();
   if (trimmed.length === 0)
     return [];
-  const topK = options.topK ?? DEFAULT_TOP_K2;
+  const topK = options.topK ?? DEFAULT_TOP_K3;
   const searchOptions = { topK, signal: options.signal };
   let result;
   try {
@@ -9086,10 +12163,11 @@ function toRetrievalResult(hit, source, methodName, instanceId, mode) {
   };
 }
 // src/datasource/skills/katok/skill.ts
+init_scope();
 var KAKAO_DATASOURCE_ID2 = "kakao";
 var KAKAO_SKILL_TYPE = "kakaotalk";
-var DEFAULT_INSTANCE_ID = "default";
-var DEFAULT_POLLING_INTERVAL_MS = 15 * 60 * 1000;
+var DEFAULT_INSTANCE_ID2 = "default";
+var DEFAULT_POLLING_INTERVAL_MS2 = 15 * 60 * 1000;
 var DEFAULT_KAKAO_TAGS2 = ["kakaotalk", "personal", "pii"];
 
 class KatokSkill {
@@ -9101,9 +12179,9 @@ class KatokSkill {
   lastIndexedAt;
   constructor(options) {
     this.client = options.client;
-    this.instanceId = options.instanceId ?? DEFAULT_INSTANCE_ID;
+    this.instanceId = options.instanceId ?? DEFAULT_INSTANCE_ID2;
     this.instances = options.instances !== undefined && options.instances.length > 0 ? options.instances : [this.instanceId];
-    this.pollingIntervalMs = options.pollingIntervalMs ?? DEFAULT_POLLING_INTERVAL_MS;
+    this.pollingIntervalMs = options.pollingIntervalMs ?? DEFAULT_POLLING_INTERVAL_MS2;
     this.tags = options.tags ?? DEFAULT_KAKAO_TAGS2;
     this.lastIndexedAt = options.lastIndexedAt;
   }
@@ -9240,6 +12318,14 @@ function sanitizeDiagnosticText2(value) {
   }
   return value;
 }
+// src/datasource/index.ts
+init_mail_export();
+init_notion();
+init_obsidian();
+init_rss();
+init_slack();
+init_spotlight();
+
 // src/index.ts
 init_jikji();
 
@@ -9274,6 +12360,7 @@ export {
   syncMinSyncWorkspace,
   selectReleaseAsset,
   saveMirrorIndex,
+  sanitizeIdSegment,
   rewriteEmbedderConfig,
   resolveReturnedPath,
   renderMemoryContext,
@@ -9311,15 +12398,25 @@ export {
   detectMirrorStaleness,
   datasourceSourcePath,
   datasourceSourceHasFragment,
+  datasourceChunkStorePath,
   createEmitResultsTool,
   createDefaultParserRegistry,
   createCheckMemoryTool,
+  connectorFailureToDiagnosticCode,
   cachedJikjiBinaryPath,
   buildSystemPrompt,
   buildMinSyncPathMap,
+  buildDatasourceSkills,
   buildDatasourceInstanceSource,
   buildDatasourceChunkSource,
+  boundDiagnosticText,
   XlsxParser,
+  SpotlightSkill,
+  SpotlightConnector,
+  SlackSkill,
+  SlackConnector,
+  RssSkill,
+  RssConnector,
   RetrievalMethodRegistry,
   RetrievalMemory,
   ResultMerger,
@@ -9330,9 +12427,15 @@ export {
   ParseError,
   ParallelRetriever,
   OpendataloaderPdfParser,
+  ObsidianSkill,
+  ObsidianConnector,
+  NotionSkill,
+  NotionConnector,
   MinSyncVectorMethod,
   MinSyncReleaseError,
   MinSyncClient,
+  MailExportSkill,
+  MailExportConnector,
   MINSYNC_SUBDIR,
   MINSYNC_FILES_SUBDIR,
   MINSYNC_CONFIG_FILE,
@@ -9346,15 +12449,27 @@ export {
   JIKJI_CRATE_NAME,
   ImageOcrParser,
   HwpParser,
+  GmailSkill,
+  GmailConnector,
+  GitHubSkill,
+  GitHubConnector,
+  GDriveSkill,
+  GDriveConnector,
   EmlParser,
   EMIT_AUTORAG_RESULTS_TOOL_NAME,
   DocxParser,
+  DiscordSkill,
+  DiscordConnector,
   DatasourceSkillRegistry,
   DatasourceResultFilter,
+  DatasourceChunkStore,
   DatasourceAccessContext,
   DEFAULT_MAX_SOURCE_BYTES,
   DEFAULT_JIKJI_OPTIONS,
   DATASOURCE_CHUNKS_SEGMENT,
+  ConnectorLexicalMethod,
+  ConnectorDatasourceSkill,
+  BUILTIN_DATASOURCE_SKILL_NAMES,
   BM25UnavailableError,
   BM25Method,
   AutoRAGAgent