@autorag/librarian 2.5.3 → 2.6.0

package/dist/core.js

@@ -146,7 +146,10 @@ function parsedOutputPath(root, virtualPath) {
 function refreshReadinessPath(root) {
   return join2(root, ".autorag", REFRESH_READINESS_FILE);
 }
-var PARSED_MIRROR_SUBDIR, PARSED_FILES_SUBDIR = "files", PARSED_INDEX_FILE = "index.json", REFRESH_READINESS_FILE = "refresh-complete.json";
+function refreshProgressPath(root) {
+  return join2(root, ".autorag", REFRESH_PROGRESS_FILE);
+}
+var PARSED_MIRROR_SUBDIR, PARSED_FILES_SUBDIR = "files", PARSED_INDEX_FILE = "index.json", REFRESH_READINESS_FILE = "refresh-complete.json", REFRESH_PROGRESS_FILE = "refresh-progress.json";
 var init_paths = __esm(() => {
   PARSED_MIRROR_SUBDIR = join2(".autorag", "parsed");
 });
@@ -1212,6 +1215,72 @@ var init_jikji = __esm(() => {
   init_types();
 });
 
+// src/language.ts
+function supportedList() {
+  return AUTORAG_LANGUAGE_TAGS.join(", ");
+}
+function toTag(raw) {
+  const tag = raw.trim().toLowerCase();
+  if (!AUTORAG_LANGUAGE_TAGS.includes(tag)) {
+    throw new LanguageError(`Unsupported language "${raw.trim()}". Supported: ${supportedList()}.`);
+  }
+  return tag;
+}
+function dedupe(tags) {
+  return [...new Set(tags)];
+}
+function normalizeLanguages(raw) {
+  if (raw === undefined || raw === null)
+    return [...DEFAULT_LANGUAGES];
+  if (typeof raw === "string")
+    return parseLanguageList(raw);
+  if (!Array.isArray(raw)) {
+    throw new LanguageError(`languages must be a string or an array of language tags; received ${typeof raw}.`);
+  }
+  const entries = raw.map((entry, index) => {
+    if (typeof entry !== "string") {
+      throw new LanguageError(`languages[${index}] must be a string language tag; received ${typeof entry}.`);
+    }
+    return entry;
+  });
+  const tags = entries.filter((entry) => entry.trim() !== "").map(toTag);
+  if (tags.length === 0) {
+    throw new LanguageError(`languages must list at least one language. Supported: ${supportedList()}.`);
+  }
+  return dedupe(tags);
+}
+function parseLanguageList(value) {
+  const tags = value.split(",").map((entry) => entry.trim()).filter((entry) => entry !== "").map(toTag);
+  if (tags.length === 0) {
+    throw new LanguageError(`languages must list at least one language. Supported: ${supportedList()}.`);
+  }
+  return dedupe(tags);
+}
+var AUTORAG_LANGUAGE_TAGS, DEFAULT_LANGUAGES, LanguageError;
+var init_language = __esm(() => {
+  AUTORAG_LANGUAGE_TAGS = [
+    "ko",
+    "en",
+    "ja",
+    "zh-hans",
+    "zh-hant",
+    "fr",
+    "de",
+    "es",
+    "ru",
+    "it",
+    "pt",
+    "vi",
+    "th",
+    "ar",
+    "hi"
+  ];
+  DEFAULT_LANGUAGES = ["ko", "en"];
+  LanguageError = class LanguageError extends Error {
+    name = "LanguageError";
+  };
+});
+
 // src/manifest/loader.ts
 import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync3 } from "node:fs";
 import { extname as extname2, join as join6 } from "node:path";
@@ -4981,475 +5050,220 @@ 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 }, (_, column) => cellsByPosition.get(`${row}:${column}`) ?? ""));
-  return [
-    `| ${header.join(" | ")} |`,
-    `| ${header.map(() => "---").join(" | ")} |`,
-    ...rows.map((row) => `| ${row.join(" | ")} |`)
-  ].join(`
-`);
+// src/parser/kordoc.ts
+import { parse as kordocParse } from "kordoc";
+function toKordocInput(bytes) {
+  return Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 }
-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}`);
-      }
-    }
+var KORDOC_EXTENSIONS, defaultParse = async (bytes, options) => {
+  const result = await kordocParse(toKordocInput(bytes), {
+    plain: true,
+    ...options.ocr === undefined ? {} : { ocr: options.ocr }
+  });
+  if (result.success) {
+    return {
+      success: true,
+      fileType: result.fileType,
+      markdown: result.markdown,
+      warnings: result.warnings
+    };
   }
-  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 as readFile3 } 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();
+  return { success: false, fileType: result.fileType, error: result.error, code: result.code };
+}, KordocParser;
+var init_kordoc = __esm(() => {
+  init_errors();
+  KORDOC_EXTENSIONS = [".hwp", ".hwpx", ".hml", ".hwpml", ".pdf", ".docx", ".xlsx", ".xls"];
+  KordocParser = class KordocParser extends Parser {
+    name = "kordoc";
+    extensions = KORDOC_EXTENSIONS;
+    #parse;
+    #ocr;
+    constructor(options = {}) {
+      super();
+      this.#parse = options.parse ?? defaultParse;
+      this.#ocr = options.ocr;
     }
-  };
-}
-function createRuntimeInitializer(runtime) {
-  let initialization;
-  return () => {
-    if (initialization === undefined) {
-      const attempt = runtime.initialize();
-      initialization = attempt.catch((error) => {
-        initialization = undefined;
-        throw error;
-      });
+    async parse(input) {
+      let result;
+      try {
+        result = await this.#parse(input.bytes, { ocr: this.#ocr });
+      } catch (cause) {
+        throw new ParseError(this.name, input.virtualPath, cause);
+      }
+      if (!result.success) {
+        throw new ParseError(this.name, input.virtualPath, new Error(`${result.code ?? "PARSE_ERROR"}: ${result.error}`));
+      }
+      const diagnostics = (result.warnings ?? []).map((warning) => ({
+        code: "parser-warning",
+        severity: "warning",
+        message: warning.code ? `${warning.code}: ${warning.message}` : warning.message
+      }));
+      return {
+        markdown: result.markdown,
+        metadata: { parser: this.name, format: result.fileType ?? "unknown" },
+        ...diagnostics.length > 0 ? { diagnostics } : {}
+      };
     }
-    return initialization;
   };
+});
+
+// src/parser/ocr.ts
+import { createWorker } from "tesseract.js";
+function engineWithNoopCleanup(engine) {
+  return (input) => ({ result: engine(input), cleanup: Promise.resolve() });
 }
-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 tesseractOcr(input) {
+  return createTesseractOcrOperation(input);
 }
-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);
+function createTesseractOcrOperation(input) {
+  let cleanupResolve = () => {
     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);
+  let cleanupReject = () => {
     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
   };
+  const cleanup = new Promise((resolve, reject) => {
+    cleanupResolve = resolve;
+    cleanupReject = reject;
+  });
+  const result = runTesseractOcr(input, cleanupResolve, cleanupReject);
+  return { result, cleanup };
 }
-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`);
+async function runTesseractOcr(input, cleanupResolve, cleanupReject) {
+  let worker;
+  let termination;
+  const terminate = async () => {
+    if (worker === undefined)
+      return;
+    termination ??= worker.terminate().then(() => {
+      return;
+    });
+    await termination;
+  };
+  const abort = () => {
+    if (worker !== undefined) {
+      terminate().then(cleanupResolve, cleanupReject);
     }
-    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;
+  };
+  input.signal.addEventListener("abort", abort, { once: true });
   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`);
+    worker = await createWorker(input.languages.join("+"));
+    if (input.signal.aborted)
+      throw new Error("OCR aborted before worker was ready");
+    const result = await worker.recognize(Buffer.from(input.bytes));
+    return result.data.text;
+  } finally {
+    input.signal.removeEventListener("abort", abort);
+    await terminate().then(cleanupResolve, cleanupReject);
   }
-  return value;
 }
-function readArray(value, label) {
-  if (!Array.isArray(value))
-    throw new TypeError(`rhwp returned invalid ${label}; expected an array`);
-  return value;
+function withTimeout(operation, timeoutMs, onTimeout) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      onTimeout();
+      operation.cleanup.finally(() => reject(new Error(`OCR timed out after ${timeoutMs}ms`)));
+    }, timeoutMs);
+    operation.result.then((value) => {
+      clearTimeout(timeout);
+      resolve(value);
+    }, (error) => {
+      clearTimeout(timeout);
+      operation.cleanup.then(() => reject(error), (cleanupError) => reject(cleanupError));
+    });
+  });
 }
-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;
+var DEFAULT_OCR_TIMEOUT_MS = 30000, DEFAULT_OCR_LANGUAGES, ImageOcrParser;
+var init_ocr = __esm(() => {
+  init_errors();
+  init_text();
+  DEFAULT_OCR_LANGUAGES = ["eng"];
+  ImageOcrParser = class ImageOcrParser extends Parser {
+    name = "image-ocr";
+    extensions = [".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".webp"];
+    languages;
+    timeoutMs;
+    maxBytes;
+    engine;
+    constructor(options) {
+      super();
+      this.languages = options.languages ?? DEFAULT_OCR_LANGUAGES;
+      this.timeoutMs = options.timeoutMs ?? DEFAULT_OCR_TIMEOUT_MS;
+      this.maxBytes = options.maxBytes;
+      this.engine = options.engine ? engineWithNoopCleanup(options.engine) : tesseractOcr;
     }
-  };
-  defaultRhwpRuntime = {
-    async initialize() {
-      const rhwpModuleUrl = import.meta.resolve("@rhwp/core");
-      const wasmBytes = await readFile3(new URL("./rhwp_bg.wasm", rhwpModuleUrl));
-      await initRhwp({ module_or_path: wasmBytes });
-    },
-    open(bytes) {
-      return new HwpDocument(bytes);
+    async parse(input) {
+      const controller = new AbortController;
+      try {
+        if (this.maxBytes !== undefined && input.bytes.byteLength > this.maxBytes) {
+          throw new Error(`OCR input exceeds maxBytes budget of ${this.maxBytes}`);
+        }
+        const operation = this.engine({
+          bytes: input.bytes,
+          languages: this.languages,
+          timeoutMs: this.timeoutMs,
+          signal: controller.signal
+        });
+        const markdown = await withTimeout(operation, this.timeoutMs, () => controller.abort());
+        return {
+          markdown: normalizeMarkdown(markdown),
+          metadata: { parser: this.name, languages: [...this.languages] }
+        };
+      } catch (cause) {
+        throw new ParseError(this.name, input.virtualPath, cause);
+      } finally {
+        controller.abort();
+      }
     }
   };
-  initializeDefaultRhwpRuntime = createRuntimeInitializer(defaultRhwpRuntime);
+});
+
+// src/parser/ocr-engines.ts
+function tesseractLanguageListFor(tags) {
+  const languages = [...new Set(tags)].map((tag) => TESSERACT_LANGUAGES[tag]);
+  if (languages.length === 0) {
+    throw new Error("OCR provider requires at least one language.");
+  }
+  return languages;
+}
+function tesseractLanguageFor(tags) {
+  return tesseractLanguageListFor(tags).join("+");
+}
+function createTesseractOcrProvider(options) {
+  const language = tesseractLanguageFor(options.languages);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TESSERACT_TIMEOUT_MS;
+  const engine = options.engine ?? ((resolvedLanguage, pageImage, pageNumber, mimeType) => defaultTesseractEngine(resolvedLanguage, pageImage, pageNumber, mimeType, timeoutMs));
+  return (pageImage, pageNumber, mimeType) => engine(language, pageImage, pageNumber, mimeType);
+}
+async function defaultTesseractEngine(language, pageImage, _pageNumber, _mimeType, timeoutMs) {
+  const controller = new AbortController;
+  const operation = createTesseractOcrOperation({
+    bytes: pageImage,
+    languages: [language],
+    timeoutMs,
+    signal: controller.signal
+  });
+  return withTimeout(operation, timeoutMs, () => controller.abort());
+}
+var TESSERACT_LANGUAGES, DEFAULT_TESSERACT_TIMEOUT_MS = 30000;
+var init_ocr_engines = __esm(() => {
+  init_ocr();
+  TESSERACT_LANGUAGES = {
+    ko: "kor",
+    en: "eng",
+    ja: "jpn",
+    "zh-hans": "chi_sim",
+    "zh-hant": "chi_tra",
+    fr: "fra",
+    de: "deu",
+    es: "spa",
+    ru: "rus",
+    it: "ita",
+    pt: "por",
+    vi: "vie",
+    th: "tha",
+    ar: "ara",
+    hi: "hin"
+  };
 });
 
 // src/parser/xml-text.ts
@@ -5552,38 +5366,22 @@ var init_xml_text = __esm(() => {
   });
 });
 
-// src/parser/hwp.ts
-import { extname as extname3 } from "node:path";
-var HwpParser;
-var init_hwp = __esm(() => {
+// src/parser/office.ts
+var PptxParser;
+var init_office = __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);
-    }
+  PptxParser = class PptxParser extends Parser {
+    name = "pptx";
+    extensions = [".pptx"];
     async parse(input) {
       try {
-        if (extname3(input.virtualPath).toLowerCase() === ".hwp") {
-          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 {
-          markdown: normalizeMarkdown(chunks.join(`
+        const chunks = await readZipXmlText(input.bytes, /^ppt\/(?:slides\/slide\d+|notesSlides\/notesSlide\d+)\.xml$/);
+        const markdown = normalizeMarkdown(chunks.filter((chunk) => chunk.trim().length > 0).join(`
 
-`)),
-          metadata: { parser: this.name, format: "hwpx" }
-        };
+`));
+        return { markdown, metadata: { parser: this.name } };
       } catch (cause) {
         throw new ParseError(this.name, input.virtualPath, cause);
       }
@@ -5591,340 +5389,21 @@ var init_hwp = __esm(() => {
   };
 });
 
-// src/parser/ocr.ts
-import { createWorker } from "tesseract.js";
-function engineWithNoopCleanup(engine) {
-  return (input) => ({ result: engine(input), cleanup: Promise.resolve() });
-}
-function tesseractOcr(input) {
-  let cleanupResolve = () => {
-    return;
-  };
-  let cleanupReject = () => {
-    return;
-  };
-  const cleanup = new Promise((resolve, reject) => {
-    cleanupResolve = resolve;
-    cleanupReject = reject;
-  });
-  const result = runTesseractOcr(input, cleanupResolve, cleanupReject);
-  return { result, cleanup };
-}
-async function runTesseractOcr(input, cleanupResolve, cleanupReject) {
-  let worker;
-  let termination;
-  const terminate = async () => {
-    if (worker === undefined)
-      return;
-    termination ??= worker.terminate().then(() => {
-      return;
-    });
-    await termination;
-  };
-  const abort = () => {
-    if (worker !== undefined) {
-      terminate().then(cleanupResolve, cleanupReject);
-    }
-  };
-  input.signal.addEventListener("abort", abort, { once: true });
-  try {
-    worker = await createWorker(input.languages.join("+"));
-    if (input.signal.aborted)
-      throw new Error("OCR aborted before worker was ready");
-    const result = await worker.recognize(Buffer.from(input.bytes));
-    return result.data.text;
-  } finally {
-    input.signal.removeEventListener("abort", abort);
-    await terminate().then(cleanupResolve, cleanupReject);
-  }
-}
-function withTimeout(operation, timeoutMs, onTimeout) {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      onTimeout();
-      operation.cleanup.finally(() => reject(new Error(`OCR timed out after ${timeoutMs}ms`)));
-    }, timeoutMs);
-    operation.result.then((value) => {
-      clearTimeout(timeout);
-      resolve(value);
-    }, (error) => {
-      clearTimeout(timeout);
-      operation.cleanup.then(() => reject(error), (cleanupError) => reject(cleanupError));
-    });
-  });
-}
-var DEFAULT_OCR_TIMEOUT_MS = 30000, DEFAULT_OCR_LANGUAGES, ImageOcrParser;
-var init_ocr = __esm(() => {
-  init_errors();
-  init_text();
-  DEFAULT_OCR_LANGUAGES = ["eng"];
-  ImageOcrParser = class ImageOcrParser extends Parser {
-    name = "image-ocr";
-    extensions = [".jpg", ".jpeg", ".png", ".bmp", ".tiff"];
-    languages;
-    timeoutMs;
-    maxBytes;
-    engine;
-    constructor(options) {
-      super();
-      this.languages = options.languages ?? DEFAULT_OCR_LANGUAGES;
-      this.timeoutMs = options.timeoutMs ?? DEFAULT_OCR_TIMEOUT_MS;
-      this.maxBytes = options.maxBytes;
-      this.engine = options.engine ? engineWithNoopCleanup(options.engine) : tesseractOcr;
-    }
-    async parse(input) {
-      const controller = new AbortController;
-      try {
-        if (this.maxBytes !== undefined && input.bytes.byteLength > this.maxBytes) {
-          throw new Error(`OCR input exceeds maxBytes budget of ${this.maxBytes}`);
-        }
-        const operation = this.engine({
-          bytes: input.bytes,
-          languages: this.languages,
-          timeoutMs: this.timeoutMs,
-          signal: controller.signal
-        });
-        const markdown = await withTimeout(operation, this.timeoutMs, () => controller.abort());
-        return {
-          markdown: normalizeMarkdown(markdown),
-          metadata: { parser: this.name, languages: [...this.languages] }
-        };
-      } catch (cause) {
-        throw new ParseError(this.name, input.virtualPath, cause);
-      } finally {
-        controller.abort();
-      }
-    }
-  };
-});
-
-// src/parser/office.ts
-import { extname as extname4 } from "node:path";
-import * as XLSX from "xlsx";
-function formatLegacyXls(bytes) {
-  const oleMagic = [208, 207, 17, 224, 161, 177, 26, 225];
-  if (bytes.length < oleMagic.length || !oleMagic.every((byte, index) => bytes[index] === byte)) {
-    throw new Error("legacy XLS input is not an OLE compound document");
-  }
-  const workbook = XLSX.read(Buffer.from(bytes), { type: "buffer", cellText: true, cellDates: true });
-  const markdown = workbook.SheetNames.map((sheetName) => {
-    const worksheet = workbook.Sheets[sheetName];
-    if (!worksheet)
-      return `## ${sheetName}`;
-    const rows = XLSX.utils.sheet_to_json(worksheet, {
-      header: 1,
-      raw: false,
-      blankrows: false,
-      defval: ""
-    });
-    const lines = rows.map((row) => formatLegacyXlsRow(row)).filter((row) => row !== undefined);
-    return [`## ${sheetName}`, ...lines].join(`
-`);
-  }).join(`
-
-`);
-  return { markdown: normalizeMarkdown(markdown), metadata: { parser: "xlsx", format: "xls" } };
-}
-function formatLegacyXlsRow(row) {
-  let lastContentIndex = -1;
-  for (let index = row.length - 1;index >= 0; index -= 1) {
-    if (String(row[index] ?? "").length > 0) {
-      lastContentIndex = index;
-      break;
-    }
-  }
-  if (lastContentIndex < 0)
-    return;
-  return row.slice(0, lastContentIndex + 1).map((cell) => escapeMarkdownTableCell(String(cell ?? ""))).join(" | ");
-}
-function escapeMarkdownTableCell(value) {
-  return value.replaceAll("\\", "\\\\").replaceAll("|", "\\|").replace(/\r\n|\r|\n/g, "<br>");
-}
-function formatMarkdown(parserName, chunks) {
-  const markdown = normalizeMarkdown(chunks.filter((chunk) => chunk.trim().length > 0).join(`
-
-`));
-  return { markdown, metadata: { parser: parserName } };
-}
-var DocxParser, PptxParser, XlsxParser;
-var init_office = __esm(() => {
-  init_errors();
-  init_text();
-  init_xml_text();
-  DocxParser = class DocxParser extends Parser {
-    name = "docx";
-    extensions = [".docx"];
-    async parse(input) {
-      try {
-        const chunks = await readZipXmlText(input.bytes, /^word\/(?:document|header\d+|footer\d+)\.xml$/);
-        return formatMarkdown(this.name, chunks);
-      } catch (cause) {
-        throw new ParseError(this.name, input.virtualPath, cause);
-      }
-    }
-  };
-  PptxParser = class PptxParser extends Parser {
-    name = "pptx";
-    extensions = [".pptx"];
-    async parse(input) {
-      try {
-        const chunks = await readZipXmlText(input.bytes, /^ppt\/(?:slides\/slide\d+|notesSlides\/notesSlide\d+)\.xml$/);
-        return formatMarkdown(this.name, chunks);
-      } catch (cause) {
-        throw new ParseError(this.name, input.virtualPath, cause);
-      }
-    }
-  };
-  XlsxParser = class XlsxParser extends Parser {
-    name = "xlsx";
-    extensions = [".xlsx", ".xls"];
-    async parse(input) {
-      try {
-        if (extname4(input.virtualPath).toLowerCase() === ".xls") {
-          return formatLegacyXls(input.bytes);
-        }
-        const sharedStrings = await readZipXmlText(input.bytes, /^xl\/sharedStrings\.xml$/);
-        const sheetText = await readZipXmlText(input.bytes, /^xl\/worksheets\/sheet\d+\.xml$/);
-        return formatMarkdown(this.name, [...sharedStrings, ...sheetText]);
-      } catch (cause) {
-        throw new ParseError(this.name, input.virtualPath, cause);
-      }
-    }
-  };
-});
-
-// src/parser/opendataloader-pdf.ts
-import { mkdtemp as mkdtemp2, readFile as readFile4, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
-import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename8, join as join16, parse as parse2 } from "node:path";
-import { convert } from "@opendataloader/pdf";
-async function readMarkdown(outputDir, inputPath) {
-  return readFile4(markdownOutputPath(outputDir, inputPath), "utf8");
-}
-function countPdfPages(bytes) {
-  const text = Buffer.from(bytes).toString("latin1");
-  return Math.max(1, [...text.matchAll(/\/Type\s*\/Page\b/gu)].length);
-}
-async function withTimeout2(operation, timeoutMs) {
-  let timer;
-  try {
-    return await Promise.race([
-      operation,
-      new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`PDF hybrid extraction timed out after ${timeoutMs}ms`)), timeoutMs);
-      })
-    ]);
-  } finally {
-    if (timer !== undefined)
-      clearTimeout(timer);
-  }
-}
-function markdownOutputPath(outputDir, inputPath) {
-  return join16(outputDir, `${parse2(inputPath).name}.md`);
-}
-var OpendataloaderPdfParser;
-var init_opendataloader_pdf = __esm(() => {
-  init_errors();
-  init_text();
-  OpendataloaderPdfParser = class OpendataloaderPdfParser extends Parser {
-    name = "opendataloader-pdf";
-    extensions = [".pdf"];
-    options;
-    converter;
-    constructor(options = {}) {
-      super();
-      this.options = options;
-      this.converter = options.converter ?? convert;
-    }
-    async parse(input) {
-      const tempRoot = await mkdtemp2(join16(tmpdir2(), "autorag-pdf-"));
-      try {
-        const inputPath = input.sourcePath ?? join16(tempRoot, basename8(input.virtualPath));
-        if (!input.sourcePath) {
-          await writeFile3(inputPath, input.bytes);
-        }
-        if (this.options.ocr?.enabled && this.options.ocr.maxBytes !== undefined && input.bytes.byteLength > this.options.ocr.maxBytes) {
-          throw new Error(`PDF OCR input exceeds maxBytes budget of ${this.options.ocr.maxBytes}`);
-        }
-        const localOptions = {
-          outputDir: tempRoot,
-          format: "markdown",
-          quiet: true,
-          imageOutput: "off",
-          ...this.options.ocr?.enabled ? {
-            hybrid: this.options.ocr.hybrid ?? "docling-fast",
-            hybridMode: this.options.ocr.hybridMode ?? "auto",
-            hybridTimeout: String(this.options.ocr.timeoutMs ?? 30000)
-          } : {}
-        };
-        await this.converter(inputPath, localOptions);
-        const localMarkdown = normalizeMarkdown(await readMarkdown(tempRoot, inputPath));
-        const pages = countPdfPages(input.bytes);
-        const thin = this.options.thinExtract;
-        const shouldRetry = this.options.ocr?.enabled !== true && thin?.enabled !== false && pages >= (thin?.minPages ?? 3) && (localMarkdown.length < (thin?.minChars ?? 800) || localMarkdown.length / pages < (thin?.minCharsPerPage ?? 40));
-        if (shouldRetry) {
-          try {
-            await withTimeout2(this.converter(inputPath, {
-              ...localOptions,
-              hybrid: thin?.hybrid ?? "docling-fast",
-              hybridMode: thin?.hybridMode ?? "auto",
-              hybridTimeout: String(thin?.timeoutMs ?? 30000)
-            }), thin?.timeoutMs ?? 30000);
-            return {
-              markdown: normalizeMarkdown(await readMarkdown(tempRoot, inputPath)),
-              metadata: { parser: this.name, pages, pdfExtract: "hybrid-retry" }
-            };
-          } catch {
-            return {
-              markdown: localMarkdown,
-              metadata: {
-                parser: this.name,
-                pages,
-                pdfExtract: "thin-local-fallback"
-              },
-              diagnostics: [
-                {
-                  code: "pdf-extract-thin",
-                  severity: "warning",
-                  message: `Local PDF extraction yielded only ${localMarkdown.length} characters across ${pages} pages.`
-                },
-                {
-                  code: "pdf-hybrid-unavailable",
-                  severity: "warning",
-                  message: "Hybrid PDF extraction was unavailable; local markdown was retained."
-                }
-              ]
-            };
-          }
-        }
-        return {
-          markdown: localMarkdown,
-          metadata: { parser: this.name, pages }
-        };
-      } catch (cause) {
-        throw new ParseError(this.name, input.virtualPath, cause);
-      } finally {
-        await rm3(tempRoot, { recursive: true, force: true });
-      }
-    }
-  };
-});
-
-// src/parser/plain-text.ts
-var PlainTextParser;
-var init_plain_text = __esm(() => {
-  init_text();
-  PlainTextParser = class PlainTextParser extends Parser {
-    name = "plain-text";
-    extensions = [".txt", ".text", ".md", ".markdown"];
-    async parse(input) {
-      return { markdown: decodeText(input.bytes), metadata: { parser: this.name } };
-    }
+// src/parser/plain-text.ts
+var PlainTextParser;
+var init_plain_text = __esm(() => {
+  init_text();
+  PlainTextParser = class PlainTextParser extends Parser {
+    name = "plain-text";
+    extensions = [".txt", ".text", ".md", ".markdown"];
+    async parse(input) {
+      return { markdown: decodeText(input.bytes), metadata: { parser: this.name } };
+    }
   };
 });
 
 // src/parser/registry.ts
-import { extname as extname5 } from "node:path";
+import { extname as extname3 } from "node:path";
 
 class ParserRegistry {
   parsersByExtension = new Map;
@@ -5943,7 +5422,7 @@ class ParserRegistry {
     }
   }
   getForVirtualPath(virtualPath) {
-    return this.parsersByExtension.get(normalizeExtension(extname5(virtualPath)));
+    return this.parsersByExtension.get(normalizeExtension(extname3(virtualPath)));
   }
   list() {
     return Array.from(new Set(this.parsersByExtension.values()));
@@ -5956,26 +5435,38 @@ function normalizeExtension(extension) {
 var init_registry = () => {};
 
 // src/parser/defaults.ts
+function resolveParserOptions(parserOptions, languages) {
+  return { ...parserOptions, languages: parserOptions?.languages ?? languages };
+}
 function createDefaultParserRegistry(options = {}) {
+  const languages = options.languages ?? DEFAULT_LANGUAGES;
+  const ocrEnabled = options.ocr?.enabled === true;
+  const kordocOptions = {
+    ...options.kordoc,
+    ...options.kordoc?.ocr === undefined && ocrEnabled ? { ocr: createTesseractOcrProvider({ languages, timeoutMs: options.ocr?.timeoutMs }) } : {}
+  };
   const parsers = [
     new PlainTextParser,
-    new OpendataloaderPdfParser({ ocr: options.ocr, thinExtract: options.thinExtract }),
-    new DocxParser,
+    new KordocParser(kordocOptions),
     new PptxParser,
-    new XlsxParser,
-    new HwpParser(options.hwp),
     new EmlParser
   ];
-  if (options.ocr?.enabled)
-    parsers.push(new ImageOcrParser(options.ocr));
+  if (ocrEnabled) {
+    parsers.push(new ImageOcrParser({
+      ...options.ocr,
+      enabled: true,
+      languages: options.ocr?.languages ?? tesseractLanguageListFor(languages)
+    }));
+  }
   return new ParserRegistry(parsers);
 }
 var init_defaults = __esm(() => {
+  init_language();
   init_eml();
-  init_hwp();
+  init_kordoc();
   init_ocr();
+  init_ocr_engines();
   init_office();
-  init_opendataloader_pdf();
   init_plain_text();
   init_registry();
 });
@@ -5983,17 +5474,8 @@ var init_defaults = __esm(() => {
 // src/mirror/sync.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { existsSync as existsSync12, mkdirSync as mkdirSync6, renameSync as renameSync5, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
-import { opendir, readFile as readFile5, stat as stat4 } from "node:fs/promises";
-import { dirname as dirname7, extname as extname6, resolve as resolve9 } from "node:path";
-function parserFailureCode(parser, error) {
-  return parser.name === "opendataloader-pdf" && /UnsupportedClassVersionError/.test(error.message) ? "pdf-java-version" : "parser-failed";
-}
-function parserFailureMessage(parser, error) {
-  if (parserFailureCode(parser, error) === "pdf-java-version") {
-    return "PDF parsing requires Java 11 or newer; the Java runtime selected from PATH is too old.";
-  }
-  return "The registered parser failed on this file; it was skipped during indexing.";
-}
+import { opendir, readFile as readFile3, stat as stat4 } from "node:fs/promises";
+import { dirname as dirname7, extname as extname4, resolve as resolve9 } from "node:path";
 async function syncParsedMirrors(options) {
   const registry = options.registry ?? createDefaultParserRegistry(options.parserOptions);
   const maxSourceBytes = options.maxSourceBytes ?? DEFAULT_MAX_SOURCE_BYTES;
@@ -6075,7 +5557,7 @@ async function syncParsedMirrors(options) {
     if (!unchanged) {
       let parsed;
       try {
-        const bytes = await readFile5(entry.sourcePath);
+        const bytes = await readFile3(entry.sourcePath);
         parsed = await parser.parse({ virtualPath: entry.virtualPath, sourcePath: entry.sourcePath, bytes });
       } catch (error) {
         if (!(error instanceof ParseError))
@@ -6085,9 +5567,9 @@ async function syncParsedMirrors(options) {
         skipped += 1;
         recordSkip(entry, "parser-failed");
         diagnostics.push({
-          code: parserFailureCode(parser, error),
+          code: "parser-failed",
           severity: "warning",
-          message: parserFailureMessage(parser, error),
+          message: PARSER_FAILURE_MESSAGE,
           source: entry.virtualPath
         });
         sinceCheckpoint += 1;
@@ -6214,7 +5696,7 @@ async function collectFiles(sourceRoot, directory, entries, supportedExtensions)
     }
     if (!entry.isFile())
       continue;
-    const extension = normalizeExtension2(extname6(entry.name));
+    const extension = normalizeExtension2(extname4(entry.name));
     if (!supportedExtensions.has(extension))
       continue;
     let fileStat;
@@ -6248,7 +5730,7 @@ function removeFile(path) {
   if (existsSync12(path))
     rmSync3(path, { force: true });
 }
-var DEFAULT_MAX_SOURCE_BYTES, MIRROR_CHECKPOINT_EVERY = 25, PRODUCT_ARTIFACT_FILE_NAMES, SKIP_DIR_NAMES;
+var DEFAULT_MAX_SOURCE_BYTES, MIRROR_CHECKPOINT_EVERY = 25, PRODUCT_ARTIFACT_FILE_NAMES, SKIP_DIR_NAMES, PARSER_FAILURE_MESSAGE = "The registered parser failed on this file; it was skipped during indexing.";
 var init_sync = __esm(() => {
   init_source_paths();
   init_defaults();
@@ -6534,6 +6016,18 @@ var init_injection_classifier = __esm(() => {
   });
 });
 
+// src/parser/index.ts
+var init_parser = __esm(() => {
+  init_defaults();
+  init_eml();
+  init_errors();
+  init_kordoc();
+  init_ocr();
+  init_office();
+  init_plain_text();
+  init_registry();
+});
+
 // src/retrieval/skip.ts
 function retrievalSurfaceFor(descriptor) {
   const datasourceId = descriptor.datasourceId;
@@ -7664,11 +7158,11 @@ var init_jikji_find_tool = __esm(() => {
 // src/agent/local-model.ts
 import { readFileSync as readFileSync9 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join17 } from "node:path";
-import { parse as parse3 } from "smol-toml";
+import { join as join16 } from "node:path";
+import { parse as parse2 } from "smol-toml";
 function loadLocalAutoRAGModel(options = {}) {
-  const configPath = options.configPath ?? join17(homedir2(), ".codex", "config.toml");
-  const config = parse3(readFileSync9(configPath, "utf8"));
+  const configPath = options.configPath ?? join16(homedir2(), ".codex", "config.toml");
+  const config = parse2(readFileSync9(configPath, "utf8"));
   const provider = config.model_provider;
   if (typeof provider !== "string" || provider.length === 0) {
     throw new Error(`AutoRAG requires model_provider in ${configPath}`);
@@ -7719,18 +7213,18 @@ import {
   watch,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { dirname as dirname10, join as join18 } from "node:path";
+import { dirname as dirname10, join as join17 } from "node:path";
 function requestsDir(workspacePath) {
-  return join18(workspacePath, P2P_DIR, "requests");
+  return join17(workspacePath, P2P_DIR, "requests");
 }
 function decisionsDir(workspacePath) {
-  return join18(workspacePath, P2P_DIR, "decisions");
+  return join17(workspacePath, P2P_DIR, "decisions");
 }
 function requestPath(workspacePath, id) {
-  return join18(requestsDir(workspacePath), `${id}.json`);
+  return join17(requestsDir(workspacePath), `${id}.json`);
 }
 function decisionPath(workspacePath, id) {
-  return join18(decisionsDir(workspacePath), `${id}.json`);
+  return join17(decisionsDir(workspacePath), `${id}.json`);
 }
 function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -7862,7 +7356,7 @@ var init_approval_store = __esm(() => {
       this.name = "ApprovalAbortedError";
     }
   };
-  P2P_DIR = join18(".autorag", "p2p");
+  P2P_DIR = join17(".autorag", "p2p");
 });
 
 // src/p2p/pii-gate.ts
@@ -8141,7 +7635,7 @@ var init_egress_gate = __esm(() => {
 
 // src/p2p/policy.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
-import { basename as basename9, dirname as dirname11, join as join19, resolve as resolve10 } from "node:path";
+import { basename as basename8, dirname as dirname11, join as join18, resolve as resolve10 } from "node:path";
 import { parse as parseToml } from "smol-toml";
 function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -8405,8 +7899,8 @@ function loadSeenSources(path, workspacePath) {
 }
 function resolveGlobalConfigPath(homePath) {
   if (homePath === undefined)
-    return join19(resolveAutoRAGHome(), "config.json");
-  return basename9(homePath) === ".autorag" ? join19(homePath, "config.json") : join19(homePath, ".autorag", "config.json");
+    return join18(resolveAutoRAGHome(), "config.json");
+  return basename8(homePath) === ".autorag" ? join18(homePath, "config.json") : join18(homePath, ".autorag", "config.json");
 }
 
 class PolicyStore {
@@ -8427,7 +7921,7 @@ class PolicyStore {
     this.workspacePath = resolve10(normalizedOptions.workspacePath);
     this.sourceRoots = normalizedOptions.sourceRoots;
     const globalConfigPath = normalizedOptions.globalConfigPath ?? resolveGlobalConfigPath(normalizedOptions.homePath);
-    const workspacePolicyPath = normalizedOptions.workspacePolicyPath ?? join19(this.workspacePath, ".autorag", "p2p", "policy.toml");
+    const workspacePolicyPath = normalizedOptions.workspacePolicyPath ?? join18(this.workspacePath, ".autorag", "p2p", "policy.toml");
     const global = readGlobalPolicy(readJsonFile(globalConfigPath), this.workspacePath, globalConfigPath);
     const workspacePolicy = readTomlFile(workspacePolicyPath);
     const workspaceEntries = readPolicyEntries(workspacePolicy, this.workspacePath, workspacePolicyPath);
@@ -8444,7 +7938,7 @@ class PolicyStore {
       throw new PolicyError("newFilesPublic must be a boolean");
     }
     this.newFilesPublic = normalizedOptions.newFilesPublic ?? workspaceNewFilesPublic ?? configuredNewFilesPublic ?? false;
-    this.seenSourcesPath = normalizedOptions.seenSourcesPath ?? join19(this.workspacePath, ".autorag", "p2p", "seen-sources.json");
+    this.seenSourcesPath = normalizedOptions.seenSourcesPath ?? join18(this.workspacePath, ".autorag", "p2p", "seen-sources.json");
     const seenState = loadSeenSources(this.seenSourcesPath, this.workspacePath);
     this.seenSources = seenState.promoted;
     this.pendingSources = seenState.pending;
@@ -8555,73 +8049,423 @@ class PolicyStore {
     if (isNewAllowSource && !this.newFilesPublic && !this.seenSources.has(canonical.normalize("NFC"))) {
       return privateResolution();
     }
-    return resolveEntry(selected, peerFingerprint);
+    return resolveEntry(selected, peerFingerprint);
+  }
+}
+function privateResolution() {
+  return { tier: "private", allowed: false, shareBytes: false, redact: true };
+}
+function resolveEntry(entry, peerFingerprint) {
+  switch (entry.tier) {
+    case "private":
+    case "never":
+      return { tier: entry.tier, allowed: false, shareBytes: false, redact: true };
+    case "always":
+      return { tier: "always", allowed: true, shareBytes: true, redact: false };
+    case "peers":
+      return {
+        tier: "peers",
+        allowed: peerFingerprint !== undefined && (entry.peers ?? []).includes(peerFingerprint),
+        shareBytes: false,
+        redact: true
+      };
+  }
+}
+var PolicyError, DEFAULT_QUOTAS, POLICY_TIERS, UNSAFE_POLICY_CHARACTERS, WINDOWS_ABSOLUTE_PATH, POSIX_FILESYSTEM_ROOTS, DEFAULT_POLICY_QUOTAS;
+var init_policy = __esm(() => {
+  init_home();
+  init_source_paths();
+  PolicyError = class PolicyError extends Error {
+    cause;
+    constructor(message, options) {
+      super(message);
+      this.name = "PolicyError";
+      this.cause = options?.cause;
+    }
+  };
+  DEFAULT_QUOTAS = {
+    queriesPerHour: 10,
+    burst: 3,
+    maxBodyBytes: 65536,
+    maxFileBytes: 26214400
+  };
+  POLICY_TIERS = new Set(["private", "never", "always", "peers"]);
+  UNSAFE_POLICY_CHARACTERS = /[\p{Cc}\p{Cf}]/u;
+  WINDOWS_ABSOLUTE_PATH = /^[a-z]:[\\/]/iu;
+  POSIX_FILESYSTEM_ROOTS = new Set([
+    "applications",
+    "bin",
+    "dev",
+    "etc",
+    "home",
+    "library",
+    "media",
+    "mnt",
+    "opt",
+    "private",
+    "proc",
+    "root",
+    "run",
+    "users",
+    "sbin",
+    "srv",
+    "system",
+    "tmp",
+    "usr",
+    "var",
+    "volumes"
+  ]);
+  DEFAULT_POLICY_QUOTAS = Object.freeze({ ...DEFAULT_QUOTAS });
+});
+
+// src/p2p/simplex-transport.ts
+import { spawn as spawn7 } from "node:child_process";
+function isRecord12(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function responseType(payload) {
+  if (!isRecord12(payload))
+    return;
+  return typeof payload.type === "string" ? payload.type : undefined;
+}
+function parseSimplexProfile(value) {
+  if (!isRecord12(value))
+    return;
+  if (typeof value.displayName !== "string" || value.displayName.trim().length === 0)
+    return;
+  const fullName = typeof value.fullName === "string" ? value.fullName : undefined;
+  const shortDescr = typeof value.shortDescr === "string" ? value.shortDescr : undefined;
+  const description = typeof value.description === "string" ? value.description : undefined;
+  const image = typeof value.image === "string" ? value.image : undefined;
+  return {
+    displayName: value.displayName,
+    ...fullName !== undefined ? { fullName } : {},
+    ...shortDescr !== undefined ? { shortDescr } : {},
+    ...description !== undefined ? { description } : {},
+    ...image !== undefined ? { image } : {}
+  };
+}
+function contactOf(payload) {
+  if (!isRecord12(payload))
+    return;
+  const contact = payload.contact;
+  if (!isRecord12(contact))
+    return;
+  if (typeof contact.contactId !== "number" || typeof contact.localDisplayName !== "string")
+    return;
+  const profile = parseSimplexProfile(contact.profile);
+  return {
+    contactId: contact.contactId,
+    localDisplayName: contact.localDisplayName,
+    ...profile !== undefined ? { profile } : {}
+  };
+}
+function userIdOf(payload) {
+  if (!isRecord12(payload))
+    return;
+  const user = payload.user;
+  if (!isRecord12(user) || typeof user.userId !== "number")
+    return;
+  return user.userId;
+}
+function extractTextFromChatItem(item) {
+  if (!isRecord12(item))
+    return;
+  const chatItem = item.chatItem;
+  if (!isRecord12(chatItem))
+    return;
+  const meta = chatItem.meta;
+  const content = chatItem.content;
+  if (!isRecord12(meta) || !isRecord12(content))
+    return;
+  if (typeof meta.itemId !== "number")
+    return;
+  const msgContent = content.msgContent;
+  if (!isRecord12(msgContent))
+    return;
+  if (msgContent.type !== "text" || typeof msgContent.text !== "string")
+    return;
+  return { chatItemId: meta.itemId, text: msgContent.text };
+}
+async function waitForPort(port, proc, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  for (;; ) {
+    if (proc.exitCode !== null) {
+      throw new SimplexError(`simplex-chat exited with code ${proc.exitCode} before the WebSocket server started`);
+    }
+    try {
+      const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+      await new Promise((resolve, reject) => {
+        ws.addEventListener("open", () => {
+          ws.close();
+          resolve();
+        });
+        ws.addEventListener("error", () => reject(new Error("connect failed")));
+      });
+      return;
+    } catch {
+      if (Date.now() >= deadline) {
+        throw new SimplexError(`simplex-chat WebSocket server did not start within ${timeoutMs}ms`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 150));
+    }
+  }
+}
+
+class SimplexClient {
+  dbPrefix;
+  displayName;
+  proc;
+  ws;
+  nextCorrId = 1;
+  pending = new Map;
+  messageHandlers = [];
+  closed = false;
+  userId;
+  constructor(dbPrefix, displayName, proc, ws) {
+    this.dbPrefix = dbPrefix;
+    this.displayName = displayName;
+    this.proc = proc;
+    this.ws = ws;
+    ws.addEventListener("message", (event) => {
+      const data = typeof event.data === "string" ? event.data : Buffer.from(event.data).toString();
+      this.dispatch(data);
+    });
+    ws.addEventListener("close", () => this.failAllPending(new SimplexError("simplex-chat WebSocket closed")));
+    ws.addEventListener("error", () => {});
+  }
+  dispatch(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!isRecord12(parsed) || !isRecord12(parsed.resp))
+      return;
+    const resp = parsed.resp;
+    if (typeof parsed.corrId === "string") {
+      const entry = this.pending.get(parsed.corrId);
+      if (entry !== undefined) {
+        this.pending.delete(parsed.corrId);
+        const type = responseType(resp);
+        if (type === "chatCmdError" || type === "chatError") {
+          entry.reject(new SimplexError(`simplex-chat command error: ${JSON.stringify(resp).slice(0, 300)}`));
+        } else {
+          entry.resolve(resp);
+        }
+      }
+      return;
+    }
+    this.handleEvent(resp);
+  }
+  handleEvent(resp) {
+    if (responseType(resp) !== "newChatItems" || !isRecord12(resp))
+      return;
+    const chatItems = resp.chatItems;
+    if (!Array.isArray(chatItems))
+      return;
+    for (const item of chatItems) {
+      if (!isRecord12(item))
+        continue;
+      const chatInfo = item.chatInfo;
+      if (!isRecord12(chatInfo) || chatInfo.type !== "direct")
+        continue;
+      const contact = contactOf(chatInfo);
+      const extracted = extractTextFromChatItem(item);
+      if (contact === undefined || extracted === undefined)
+        continue;
+      const chatItem = item.chatItem;
+      if (!isRecord12(chatItem))
+        continue;
+      const chatDir = chatItem.chatDir;
+      if (!isRecord12(chatDir) || chatDir.type !== "directRcv")
+        continue;
+      const message = {
+        contactId: contact.contactId,
+        contactName: contact.localDisplayName,
+        text: extracted.text,
+        chatItemId: extracted.chatItemId
+      };
+      for (const handler of this.messageHandlers) {
+        try {
+          handler(message);
+        } catch {}
+      }
+    }
+  }
+  cmd(command) {
+    if (this.closed)
+      return Promise.reject(new SimplexError("transport is closed"));
+    const corrId = String(this.nextCorrId++);
+    return new Promise((resolve, reject) => {
+      this.pending.set(corrId, { resolve, reject });
+      const request = { corrId, cmd: command };
+      try {
+        this.ws.send(JSON.stringify(request));
+      } catch (error) {
+        this.pending.delete(corrId);
+        reject(new SimplexError(`WebSocket send failed: ${error instanceof Error ? error.message : String(error)}`));
+      }
+    });
+  }
+  failAllPending(error) {
+    for (const entry of this.pending.values())
+      entry.reject(error);
+    this.pending.clear();
+  }
+  async requireUserId() {
+    if (this.userId !== undefined)
+      return this.userId;
+    const active = await this.cmd("/user");
+    if (responseType(active) === "activeUser") {
+      const id = userIdOf(active);
+      if (id !== undefined) {
+        this.userId = id;
+        return id;
+      }
+    }
+    const created = await this.cmd(`/_create user ${JSON.stringify({
+      profile: { displayName: this.displayName, fullName: "" },
+      pastTimestamp: false,
+      userChatRelay: false,
+      clientService: false
+    })}`);
+    if (responseType(created) !== "activeUser") {
+      throw new SimplexError(`failed to create SimpleX user profile: ${JSON.stringify(created).slice(0, 300)}`);
+    }
+    const id = userIdOf(created);
+    if (id === undefined)
+      throw new SimplexError("simplex-chat did not return a user id");
+    this.userId = id;
+    return id;
+  }
+  async getUserId() {
+    return this.requireUserId();
+  }
+  async getOrCreateAddress() {
+    const userId = await this.requireUserId();
+    try {
+      const existing = await this.cmd(`/_show_address ${userId}`);
+      if (responseType(existing) === "userContactLink" && isRecord12(existing)) {
+        const link = existing.contactLink;
+        if (isRecord12(link) && isRecord12(link.connLinkContact)) {
+          const full = link.connLinkContact.connFullLink;
+          if (typeof full === "string")
+            return full;
+        }
+      }
+    } catch {}
+    const created = await this.cmd(`/_address ${userId}`);
+    if (responseType(created) !== "userContactLinkCreated" || !isRecord12(created)) {
+      throw new SimplexError(`failed to create SimpleX address: ${JSON.stringify(created).slice(0, 300)}`);
+    }
+    const link = created.connLinkContact;
+    if (!isRecord12(link) || typeof link.connFullLink !== "string") {
+      throw new SimplexError("simplex-chat did not return a contact address");
+    }
+    await this.cmd(`/_address_settings ${userId} ${JSON.stringify({
+      businessAddress: false,
+      autoAccept: { acceptIncognito: false }
+    })}`);
+    return link.connFullLink;
+  }
+  async createInvitation() {
+    const userId = await this.requireUserId();
+    const resp = await this.cmd(`/_connect ${userId}`);
+    if (responseType(resp) !== "invitation" || !isRecord12(resp)) {
+      throw new SimplexError(`failed to create invitation: ${JSON.stringify(resp).slice(0, 300)}`);
+    }
+    const link = resp.connLinkInvitation;
+    if (!isRecord12(link) || typeof link.connFullLink !== "string") {
+      throw new SimplexError("simplex-chat did not return an invitation link");
+    }
+    return link.connFullLink;
+  }
+  async connect(link) {
+    const userId = await this.requireUserId();
+    const resp = await this.cmd(`/_connect ${userId} ${link}`);
+    const type = responseType(resp);
+    if (type === "sentInvitation" || type === "sentConfirmation" || type === "contactAlreadyExists")
+      return;
+    throw new SimplexError(`failed to connect via link: ${JSON.stringify(resp).slice(0, 300)}`);
+  }
+  async listContacts() {
+    const userId = await this.requireUserId();
+    const resp = await this.cmd(`/_contacts ${userId}`);
+    if (responseType(resp) !== "contactsList" || !isRecord12(resp) || !Array.isArray(resp.contacts)) {
+      throw new SimplexError(`failed to list contacts: ${JSON.stringify(resp).slice(0, 300)}`);
+    }
+    const contacts = [];
+    for (const entry of resp.contacts) {
+      const contact = contactOf({ contact: entry });
+      if (contact !== undefined)
+        contacts.push(contact);
+    }
+    return contacts;
   }
-}
-function privateResolution() {
-  return { tier: "private", allowed: false, shareBytes: false, redact: true };
-}
-function resolveEntry(entry, peerFingerprint) {
-  switch (entry.tier) {
-    case "private":
-    case "never":
-      return { tier: entry.tier, allowed: false, shareBytes: false, redact: true };
-    case "always":
-      return { tier: "always", allowed: true, shareBytes: true, redact: false };
-    case "peers":
-      return {
-        tier: "peers",
-        allowed: peerFingerprint !== undefined && (entry.peers ?? []).includes(peerFingerprint),
-        shareBytes: false,
-        redact: true
-      };
+  async sendMessage(contactId, text) {
+    const resp = await this.cmd(`/_send @${contactId} json ${JSON.stringify([{ msgContent: { type: "text", text }, mentions: {} }])}`);
+    if (responseType(resp) !== "newChatItems") {
+      throw new SimplexError(`failed to send message: ${JSON.stringify(resp).slice(0, 300)}`);
+    }
+  }
+  onMessage(handler) {
+    this.messageHandlers.push(handler);
+    return () => {
+      const index = this.messageHandlers.indexOf(handler);
+      if (index !== -1)
+        this.messageHandlers.splice(index, 1);
+    };
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.failAllPending(new SimplexError("transport closed"));
+    try {
+      this.ws.close();
+    } catch {}
+    this.proc.kill("SIGTERM");
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.proc.kill("SIGKILL");
+        resolve();
+      }, 3000);
+      this.proc.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
   }
 }
-var PolicyError, DEFAULT_QUOTAS, POLICY_TIERS, UNSAFE_POLICY_CHARACTERS, WINDOWS_ABSOLUTE_PATH, POSIX_FILESYSTEM_ROOTS, DEFAULT_POLICY_QUOTAS;
-var init_policy = __esm(() => {
-  init_home();
-  init_source_paths();
-  PolicyError = class PolicyError extends Error {
-    cause;
-    constructor(message, options) {
+async function startSimplexChat(options) {
+  const port = options.port ?? 5225;
+  const binary = options.binary ?? "simplex-chat";
+  const args = ["-p", String(port), "-d", options.dbPrefix];
+  if (options.displayName !== undefined)
+    args.push("--create-bot-display-name", options.displayName);
+  const proc = spawn7(binary, args, {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  await waitForPort(port, proc, options.connectTimeoutMs ?? 15000);
+  const ws = await new Promise((resolve, reject) => {
+    const sock = new WebSocket(`ws://127.0.0.1:${port}`);
+    sock.addEventListener("open", () => resolve(sock));
+    sock.addEventListener("error", () => reject(new SimplexError(`WebSocket connect failed on port ${port}`)));
+  });
+  const client = new SimplexClient(options.dbPrefix, options.displayName, proc, ws);
+  await client.getUserId();
+  return client;
+}
+var SimplexError;
+var init_simplex_transport = __esm(() => {
+  SimplexError = class SimplexError extends Error {
+    constructor(message) {
       super(message);
-      this.name = "PolicyError";
-      this.cause = options?.cause;
+      this.name = "SimplexError";
     }
   };
-  DEFAULT_QUOTAS = {
-    queriesPerHour: 10,
-    burst: 3,
-    maxBodyBytes: 65536,
-    maxFileBytes: 26214400
-  };
-  POLICY_TIERS = new Set(["private", "never", "always", "peers"]);
-  UNSAFE_POLICY_CHARACTERS = /[\p{Cc}\p{Cf}]/u;
-  WINDOWS_ABSOLUTE_PATH = /^[a-z]:[\\/]/iu;
-  POSIX_FILESYSTEM_ROOTS = new Set([
-    "applications",
-    "bin",
-    "dev",
-    "etc",
-    "home",
-    "library",
-    "media",
-    "mnt",
-    "opt",
-    "private",
-    "proc",
-    "root",
-    "run",
-    "users",
-    "sbin",
-    "srv",
-    "system",
-    "tmp",
-    "usr",
-    "var",
-    "volumes"
-  ]);
-  DEFAULT_POLICY_QUOTAS = Object.freeze({ ...DEFAULT_QUOTAS });
 });
 
 // src/p2p/wire.ts
@@ -8683,24 +8527,34 @@ var init_wire = __esm(() => {
 
 // src/p2p/simplex-server.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join19 } from "node:path";
 import { Type as Type9 } from "typebox";
 import { Value } from "typebox/value";
 function targetTokens(value) {
   return new Set((value.toLocaleLowerCase().match(TARGET_TOKEN_PATTERN) ?? []).filter((token) => token.length > 1));
 }
+function contactText(alias, peer) {
+  return [
+    alias,
+    peer.description,
+    peer.profile?.displayName,
+    peer.profile?.fullName,
+    peer.profile?.shortDescr,
+    peer.profile?.description
+  ].filter((value) => value !== undefined).join(" ");
+}
 function rankSimplexPeerTargets(query, registry) {
   const queryTerms = targetTokens(query);
   if (queryTerms.size === 0)
     return [];
   return Object.entries(registry).map(([alias, peer]) => {
-    const peerTerms = targetTokens([alias, peer.displayName, peer.description, peer.role, peer.org, ...peer.accessHint ?? []].filter((value) => value !== undefined).join(" "));
+    const peerTerms = targetTokens(contactText(alias, peer));
     const matchedTerms = [...queryTerms].filter((term) => peerTerms.has(term)).sort();
     return { alias, score: matchedTerms.length, matchedTerms };
   }).filter((match) => match.score > 0).sort((left, right) => right.score - left.score || left.alias.localeCompare(right.alias));
 }
 function loadSimplexPeerRegistry(workspacePath) {
-  const path = join20(workspacePath, PEERS_DIR, PEERS_FILENAME);
+  const path = join19(workspacePath, PEERS_DIR, PEERS_FILENAME);
   if (!existsSync15(path))
     return {};
   try {
@@ -8711,15 +8565,13 @@ function loadSimplexPeerRegistry(workspacePath) {
     for (const [alias, record] of Object.entries(parsed)) {
       if (typeof record === "object" && record !== null && typeof record.contactId === "number" && typeof record.addedAt === "string") {
         const raw = record;
-        const accessHint = Array.isArray(raw.accessHint) ? raw.accessHint.filter((value) => typeof value === "string") : undefined;
+        const profile = parseSimplexProfile(raw.profile);
         registry[alias] = {
           contactId: raw.contactId,
           addedAt: raw.addedAt,
-          ...typeof raw.displayName === "string" ? { displayName: raw.displayName } : {},
-          ...typeof raw.description === "string" ? { description: raw.description } : {},
-          ...typeof raw.role === "string" ? { role: raw.role } : {},
-          ...typeof raw.org === "string" ? { org: raw.org } : {},
-          ...accessHint !== undefined ? { accessHint } : {}
+          ...profile !== undefined ? { profile } : {},
+          ...typeof raw.profileSyncedAt === "string" ? { profileSyncedAt: raw.profileSyncedAt } : {},
+          ...typeof raw.description === "string" ? { description: raw.description } : {}
         };
       }
     }
@@ -8729,9 +8581,29 @@ function loadSimplexPeerRegistry(workspacePath) {
   }
 }
 function saveSimplexPeerRegistry(workspacePath, registry) {
-  const dir = join20(workspacePath, PEERS_DIR);
+  const dir = join19(workspacePath, PEERS_DIR);
   mkdirSync10(dir, { recursive: true });
-  writeFileSync9(join20(dir, PEERS_FILENAME), JSON.stringify(registry, null, 2), { mode: 384 });
+  writeFileSync9(join19(dir, PEERS_FILENAME), JSON.stringify(registry, null, 2), { mode: 384 });
+}
+function syncSimplexPeers(workspacePath, contacts, syncedAt = new Date().toISOString()) {
+  const registry = loadSimplexPeerRegistry(workspacePath);
+  const updated = [];
+  const untrusted = [];
+  for (const contact of contacts) {
+    const entry = Object.entries(registry).find(([, peer]) => peer.contactId === contact.contactId);
+    if (entry === undefined) {
+      untrusted.push(contact);
+      continue;
+    }
+    if (contact.profile === undefined)
+      continue;
+    const [alias, peer] = entry;
+    registry[alias] = { ...peer, profile: contact.profile, profileSyncedAt: syncedAt };
+    updated.push(alias);
+  }
+  if (updated.length > 0)
+    saveSimplexPeerRegistry(workspacePath, registry);
+  return { updated, untrusted };
 }
 function consumeToken(buckets, contactId, quotas) {
   const now = Date.now();
@@ -8961,6 +8833,7 @@ var init_simplex_server = __esm(() => {
   init_injection_classifier();
   init_injection_gate();
   init_policy();
+  init_simplex_transport();
   init_wire();
   PRIVATE_POLICY = {
     tier: "private",
@@ -8975,7 +8848,7 @@ var init_simplex_server = __esm(() => {
     payload: Type9.Unknown({ description: "PeerQueryRequest or PeerQueryResponse" })
   });
   TARGET_TOKEN_PATTERN = /[\p{L}\p{N}]+/gu;
-  PEERS_DIR = join20(".autorag", "p2p");
+  PEERS_DIR = join19(".autorag", "p2p");
   QueueFullError = class QueueFullError extends Error {
     constructor(message = "The peer query queue is full.") {
       super(message);
@@ -8999,7 +8872,7 @@ function createRecommendPeerTargetsTool(workspacePath) {
         return {
           alias: match.alias,
           matchedTerms: match.matchedTerms,
-          ...peer?.displayName !== undefined ? { displayName: peer.displayName } : {},
+          ...peer?.profile?.displayName !== undefined ? { displayName: peer.profile.displayName } : {},
           ...peer?.description !== undefined ? { description: peer.description } : {}
         };
       });
@@ -9023,6 +8896,80 @@ var init_peer_target_tool = __esm(() => {
   });
 });
 
+// src/agent/refresh-progress.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync13, renameSync as renameSync7, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
+function readRefreshProgress(root) {
+  try {
+    const parsed = JSON.parse(readFileSync13(refreshProgressPath(root), "utf8"));
+    return isPersistedRefreshProgress(parsed) ? parsed : undefined;
+  } catch (error) {
+    if (error instanceof SyntaxError || typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+function writeRefreshProgress(root, progress) {
+  const path = refreshProgressPath(root);
+  mkdirSync11(dirname12(path), { recursive: true });
+  const temporaryPath = `${path}.${randomUUID6()}.tmp`;
+  try {
+    writeFileSync10(temporaryPath, `${JSON.stringify(progress, null, 2)}
+`);
+    renameSync7(temporaryPath, path);
+  } finally {
+    rmSync4(temporaryPath, { force: true });
+  }
+}
+function updateRefreshProgress(progress, update) {
+  return {
+    ...progress,
+    ...update,
+    updatedAt: new Date().toISOString()
+  };
+}
+function removeRefreshProgress(root) {
+  rmSync4(refreshProgressPath(root), { force: true });
+}
+function isRefreshOwnerAlive(progress) {
+  if (progress.state !== "running")
+    return false;
+  try {
+    process.kill(progress.pid, 0);
+    return true;
+  } catch (error) {
+    if (error instanceof Error)
+      return false;
+    throw error;
+  }
+}
+function isPersistedRefreshProgress(value) {
+  if (!isRecord13(value))
+    return false;
+  const record = value;
+  return record.version === 1 && typeof record.runId === "string" && typeof record.pid === "number" && Number.isInteger(record.pid) && (record.state === "running" || record.state === "success" || record.state === "failed") && isRefreshProgressPhase(record.phase) && typeof record.startedAt === "string" && typeof record.updatedAt === "string" && (record.finishedAt === undefined || typeof record.finishedAt === "string") && (record.error === undefined || typeof record.error === "string") && isSourceFiles(record.sourceFiles) && isParsedCounts(record.parsedCounts) && isMinsync(record.minsync);
+}
+function isRefreshProgressPhase(value) {
+  return value === "parsed" || value === "minsync" || value === "datasources" || value === "jikji" || value === "finalizing";
+}
+function isSourceFiles(value) {
+  return value === undefined || isRecord13(value) && typeof value.total === "number" && Number.isInteger(value.total);
+}
+function isParsedCounts(value) {
+  return value === undefined || isRecord13(value) && typeof value.scanned === "number" && typeof value.written === "number" && typeof value.deleted === "number" && typeof value.skipped === "number";
+}
+function isMinsync(value) {
+  return value === undefined || isRecord13(value) && (value.synced === undefined || typeof value.synced === "number");
+}
+function isRecord13(value) {
+  return typeof value === "object" && value !== null;
+}
+var init_refresh_progress = __esm(() => {
+  init_paths();
+});
+
 // src/agent/search-documents.ts
 function toRetrievalTraceResults(results, limit = 5, excerptChars = 300) {
   return results.slice(0, limit).map((result) => ({
@@ -9622,19 +9569,6 @@ var init_watch_refresh = __esm(() => {
   EXCLUDED_SEGMENTS = new Set([".autorag", ".git", "node_modules"]);
 });
 
-// src/parser/index.ts
-var init_parser = __esm(() => {
-  init_defaults();
-  init_eml();
-  init_errors();
-  init_hwp();
-  init_ocr();
-  init_office();
-  init_opendataloader_pdf();
-  init_plain_text();
-  init_registry();
-});
-
 // src/web/entities.ts
 function decodeHtmlEntities(value) {
   return value.replace(ENTITY_PATTERN, (match, body) => {
@@ -9823,7 +9757,7 @@ var init_page_loader = __esm(() => {
 });
 
 // src/web/fetch/url-target.ts
-import { extname as extname7 } from "node:path";
+import { extname as extname5 } from "node:path";
 function repairCollapsedScheme(value) {
   const m = value.match(/^(https?):\/(?!\/)/i);
   return m ? `${m[1]}://${value.slice(m[0].length)}` : value;
@@ -9842,7 +9776,7 @@ function getFilenameExtensionHint(filename) {
   const lower = filename.toLowerCase();
   if (lower.endsWith(".tar.gz"))
     return ".tar.gz";
-  return extname7(filename).toLowerCase();
+  return extname5(filename).toLowerCase();
 }
 function getExtensionHint(url, contentDisposition) {
   if (contentDisposition) {
@@ -9910,9 +9844,9 @@ var init_url_target = __esm(() => {
 });
 
 // src/web/fetch/convert.ts
-import { mkdtemp as mkdtemp3, rm as rm4, writeFile as writeFile4 } from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join21 } from "node:path";
+import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join20 } from "node:path";
 function combineSignals2(signal, timeoutMs) {
   if (!signal)
     return AbortSignal.timeout(timeoutMs);
@@ -9988,10 +9922,10 @@ async function convertBinaryPayload(buffer, extension, _finalUrl, signal) {
   if (!parser) {
     return { content: "", ok: false, error: `No parser registered for ${ext}` };
   }
-  const tempDir = await mkdtemp3(join21(tmpdir3(), "autorag-fetch-"));
-  const tempPath = join21(tempDir, `payload${ext}`);
+  const tempDir = await mkdtemp2(join20(tmpdir2(), "autorag-fetch-"));
+  const tempPath = join20(tempDir, `payload${ext}`);
   try {
-    await writeFile4(tempPath, buffer);
+    await writeFile3(tempPath, buffer);
     const input = {
       virtualPath: `payload${ext}`,
       sourcePath: tempPath,
@@ -10008,7 +9942,7 @@ async function convertBinaryPayload(buffer, extension, _finalUrl, signal) {
       error: err instanceof Error ? err.message : "Conversion failed"
     };
   } finally {
-    await rm4(tempDir, { recursive: true, force: true });
+    await rm3(tempDir, { recursive: true, force: true });
   }
 }
 var parserRegistry;
@@ -10019,7 +9953,7 @@ var init_convert = __esm(() => {
 });
 
 // src/web/fetch/feeds.ts
-import { extname as extname8 } from "node:path";
+import { extname as extname6 } from "node:path";
 import { XMLParser as XMLParser2 } from "fast-xml-parser";
 function getHtmlAttribute(tag, attribute) {
   const pattern = new RegExp(`\\b${attribute}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'=<>]+))`, "i");
@@ -10082,7 +10016,7 @@ function extractDocumentLinks(html, baseUrl) {
       const href = getHtmlAttribute(tag, "href");
       if (!href)
         continue;
-      const ext = extname8(href).toLowerCase();
+      const ext = extname6(href).toLowerCase();
       if (!CONVERTIBLE_EXTENSIONS2.has(ext))
         continue;
       const resolved = href.startsWith("http") ? href : new URL(href, baseUrl).href;
@@ -10241,7 +10175,7 @@ function alignmentMarker(cell) {
     return "--:";
   return "---";
 }
-function renderTable2(service, table) {
+function renderTable(service, table) {
   const rows = descendantElements(table, "TR");
   const rendered = [];
   for (let rowIndex = 0;rowIndex < rows.length; rowIndex++) {
@@ -10298,7 +10232,7 @@ ${options.fence}
   service.addRule("table", {
     filter: isHeadingTable,
     replacement(_content, node) {
-      return renderTable2(service, node);
+      return renderTable(service, node);
     }
   });
 }, gfm = (service) => {
@@ -15250,9 +15184,9 @@ var init_web_search_tool = __esm(() => {
 });
 
 // src/agent/agent.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { existsSync as existsSync17, watch as fsWatch, mkdirSync as mkdirSync11, realpathSync as realpathSync4, statSync, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname12, join as join22, resolve as resolve11 } from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { existsSync as existsSync17, watch as fsWatch, mkdirSync as mkdirSync12, realpathSync as realpathSync4, statSync, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname13, join as join21, resolve as resolve11 } from "node:path";
 import { Agent } from "@earendil-works/pi-agent-core";
 import { clampThinkingLevel, streamSimple } from "@earendil-works/pi-ai/compat";
 
@@ -15294,6 +15228,7 @@ class AutoRAGAgent {
   };
   searchPaths;
   configuredSearchPaths;
+  languages;
   retrievalScopeBindings;
   datasourceVirtualScopePrefixes;
   workspaceProjectRoot;
@@ -15341,10 +15276,11 @@ class AutoRAGAgent {
     this.startupDiagnostics = options.startupDiagnostics ?? [];
     this.datasourceAgentSkills = this.buildAuthorizedDatasourceSkills();
     this.configuredSearchPaths = options.searchPaths.map((searchPath) => resolve11(searchPath));
+    this.languages = options.languages ?? DEFAULT_LANGUAGES;
     this.searchPaths = options.searchPaths.map(pinSearchRoot);
     this.workspaceProjectRoot = options.workspacePath ?? process.cwd();
     this.retrievalScopeBindings = buildRetrievalScopeBindings(this.workspaceProjectRoot, this.searchPaths, this.configuredSearchPaths);
-    this.parserOptions = options.parserOptions;
+    this.parserOptions = resolveParserOptions(options.parserOptions, this.languages);
     this.dupeyOptions = options.dupey ?? {};
     this.excludeExactDuplicates = options.excludeExactDuplicates ?? true;
     if (options.minSync !== false) {
@@ -15368,10 +15304,10 @@ class AutoRAGAgent {
       });
       this.jikjiReady = this.searchPaths.every((searchPath) => this.jikjiClient?.isPrepared(searchPath) === true);
     }
-    const memPath = memoryPath ?? join22(resolveAutoRAGHome(), "memory.json");
+    const memPath = memoryPath ?? join21(resolveAutoRAGHome(), "memory.json");
     this.memory = new RetrievalMemory({ storagePath: memPath });
     this.memory.load();
-    this.runLogger = new AutoRAGRunLogger(join22(dirname12(memPath), "logs", "runs.jsonl"));
+    this.runLogger = new AutoRAGRunLogger(join21(dirname13(memPath), "logs", "runs.jsonl"));
     const checkMemoryTool = createCheckMemoryTool(this.memory);
     const singleDatasourceTools = createSingleDatasourceSearchTools(this, this.singleDatasourceToolSpecs());
     this.searchToolNames = new Set([...SEARCH_TOOLS, ...singleDatasourceTools.map((tool) => tool.name)]);
@@ -15645,7 +15581,7 @@ ${summary}
     if (this.activeRun) {
       throw new Error("AutoRAG agent is busy; await the in-flight searchDocuments() call before starting another");
     }
-    const sessionId = randomUUID6();
+    const sessionId = randomUUID7();
     const trimmedQuery = query.trim();
     if (trimmedQuery.length === 0) {
       this.lastQuery = trimmedQuery;
@@ -16148,16 +16084,54 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
     const allMethods = methods === undefined;
     const wants = (m) => allMethods || methods.includes(m);
     const needsParsed = allMethods || wants("parsed") || wants("minsync");
+    const runId = randomUUID7();
+    const startedAt = new Date().toISOString();
+    let progress = {
+      version: 1,
+      runId,
+      pid: process.pid,
+      state: "running",
+      phase: "parsed",
+      startedAt,
+      updatedAt: startedAt
+    };
+    writeRefreshProgress(this.workspaceProjectRoot, progress);
     this.refreshState = {
       ...this.refreshState,
       inFlight: true,
-      lastStartedAt: new Date().toISOString()
+      lastStartedAt: startedAt
     };
     try {
       const summary = needsParsed ? await this.syncParsedMirrors(force) : await this.scanMirrorStaleness();
+      progress = updateRefreshProgress(progress, {
+        phase: wants("minsync") ? "minsync" : wants("datasources") ? "datasources" : wants("jikji") ? "jikji" : "finalizing",
+        sourceFiles: { total: summary.scanned },
+        parsedCounts: {
+          scanned: summary.scanned,
+          written: summary.written,
+          deleted: summary.deleted,
+          skipped: summary.skipped
+        }
+      });
+      writeRefreshProgress(this.workspaceProjectRoot, progress);
       const minsync = wants("minsync") ? await this.syncMinSync(force) : undefined;
+      if (minsync !== undefined) {
+        progress = updateRefreshProgress(progress, {
+          phase: wants("datasources") ? "datasources" : wants("jikji") ? "jikji" : "finalizing",
+          minsync: { synced: minsync.synced }
+        });
+        writeRefreshProgress(this.workspaceProjectRoot, progress);
+      }
       const datasources = wants("datasources") ? await this.indexDatasources() : [];
+      if (wants("datasources")) {
+        progress = updateRefreshProgress(progress, {
+          phase: wants("jikji") || allMethods ? "jikji" : "finalizing"
+        });
+        writeRefreshProgress(this.workspaceProjectRoot, progress);
+      }
       const jikji = allMethods || wants("jikji") || wants("minsync") ? await this.executeJikjiPrepare() : undefined;
+      progress = updateRefreshProgress(progress, { phase: "finalizing" });
+      writeRefreshProgress(this.workspaceProjectRoot, progress);
       this.retrievalScopeBindings = buildRetrievalScopeBindings(this.workspaceProjectRoot, this.searchPaths, this.configuredSearchPaths);
       const jikjiDiagnostics = (jikji ?? []).map((result) => jikjiPrepareDiagnostic(result)).filter((diag) => diag !== undefined);
       this.refreshState = {
@@ -16176,10 +16150,15 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
         lastError: undefined
       };
       if (needsParsed) {
-        mkdirSync11(dirname12(refreshReadinessPath(this.workspaceProjectRoot)), { recursive: true });
-        writeFileSync10(refreshReadinessPath(this.workspaceProjectRoot), `{"version":1,"completed":true,"parsed":true}
+        mkdirSync12(dirname13(refreshReadinessPath(this.workspaceProjectRoot)), { recursive: true });
+        writeFileSync11(refreshReadinessPath(this.workspaceProjectRoot), `{"version":1,"completed":true,"parsed":true}
 `);
       }
+      progress = updateRefreshProgress(progress, {
+        state: "success",
+        finishedAt: new Date().toISOString()
+      });
+      writeRefreshProgress(this.workspaceProjectRoot, progress);
       const minsyncDiagnostics = minSyncRefreshDiagnostics(minsync);
       const publicMinsync = minsync ? {
         ok: minsync.ok,
@@ -16205,6 +16184,12 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
         lastOutcome: "failed",
         lastError: error instanceof Error ? `Refresh failed: ${error.name}` : "Refresh failed."
       };
+      progress = updateRefreshProgress(progress, {
+        state: "failed",
+        error: this.refreshState.lastError,
+        finishedAt: new Date().toISOString()
+      });
+      writeRefreshProgress(this.workspaceProjectRoot, progress);
       throw error;
     } finally {
       this.refreshState = {
@@ -16215,6 +16200,7 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
     }
   }
   async getRefreshStatus() {
+    const persistedProgress = readRefreshProgress(this.workspaceProjectRoot);
     const staleDiagnostics = await detectMirrorStaleness({
       root: this.workspaceProjectRoot,
       searchPaths: this.searchPaths,
@@ -16255,18 +16241,37 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
         source: "watch"
       });
     }
-    const state = this.refreshState.inFlight ? "indexing" : this.refreshState.lastOutcome === "never" ? "idle" : this.refreshState.lastOutcome;
-    const parsedMirrorReady = this.refreshState.lastOutcome === "success" || existsSync17(refreshReadinessPath(this.workspaceProjectRoot));
+    const persistedRunning = persistedProgress?.state === "running";
+    const ownerAlive = persistedProgress !== undefined && isRefreshOwnerAlive(persistedProgress);
+    const interrupted = persistedRunning && !ownerAlive && !this.refreshState.inFlight;
+    if (interrupted) {
+      diagnostics.push({
+        code: "refresh-interrupted",
+        severity: "error",
+        message: "A previous refresh stopped before it completed.",
+        source: "refresh"
+      });
+    }
+    const state = this.refreshState.inFlight || persistedRunning && ownerAlive ? "indexing" : interrupted ? "failed" : persistedProgress?.state === "success" || persistedProgress?.state === "failed" ? persistedProgress.state : this.refreshState.lastOutcome === "never" ? "idle" : this.refreshState.lastOutcome;
+    const parsedMirrorReady = this.refreshState.lastOutcome === "success" || persistedProgress?.state === "success" || existsSync17(refreshReadinessPath(this.workspaceProjectRoot));
+    const effectiveProgress = this.refreshState.inFlight || persistedRunning ? persistedProgress : undefined;
     return {
       state,
       inFlight: this.refreshState.inFlight,
-      lastStartedAt: this.refreshState.lastStartedAt,
-      lastFinishedAt: this.refreshState.lastFinishedAt,
+      lastStartedAt: this.refreshState.lastStartedAt ?? persistedProgress?.startedAt,
+      lastFinishedAt: this.refreshState.lastFinishedAt ?? persistedProgress?.finishedAt,
       counts: this.refreshState.counts,
+      progress: effectiveProgress === undefined ? undefined : {
+        phase: effectiveProgress.phase,
+        sourceFiles: effectiveProgress.sourceFiles,
+        parsedCounts: effectiveProgress.parsedCounts,
+        minsync: effectiveProgress.minsync,
+        ownerAlive
+      },
       stale: !parsedMirrorReady || staleDiagnostics.length > 0,
       diagnostics,
       components: this.refreshComponentStatus(),
-      lastError: this.refreshState.lastError
+      lastError: this.refreshState.lastError ?? (persistedProgress?.state === "failed" ? persistedProgress.error : undefined)
     };
   }
   refreshComponentStatus() {
@@ -16338,7 +16343,7 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
       written: 0,
       deleted: 0,
       skipped: 0,
-      indexPath: join22(this.workspaceProjectRoot, PARSED_MIRROR_SUBDIR),
+      indexPath: join21(this.workspaceProjectRoot, PARSED_MIRROR_SUBDIR),
       diagnostics
     };
   }
@@ -16698,7 +16703,7 @@ function buildMissingFinalEmitAnswer(query, reason, trace) {
   const lines = [
     `The search run for "${query}" ended without finalized results: the agent ended its run without calling emit_autorag_results, so no curated answer is available within the configured search range.`,
     reason === undefined ? "The agent did not record why it stopped." : `The agent's last note before stopping: "${reason.length > 500 ? `${reason.slice(0, 500)}…` : reason}"`,
-    "Next steps: broaden the configured searchPaths, connect additional datasources (for example via `autorag ui` or the datasources configuration), or retry with a narrower or different query.",
+    "Next steps: broaden the configured searchPaths, connect additional datasources via the datasources configuration, or retry with a narrower or different query.",
     trace.length > 0 ? "Retrieval candidates gathered before the run ended are attached under `retrievalTrace` for inspection." : "No retrieval candidates were gathered before the run ended."
   ];
   return lines.join(`
@@ -16802,6 +16807,7 @@ var init_agent = __esm(() => {
   init_dupey();
   init_diagnostics();
   init_jikji();
+  init_language();
   init_loader();
   init_check_memory_tool();
   init_memory();
@@ -16810,6 +16816,7 @@ var init_agent = __esm(() => {
   init_sync();
   init_run_log();
   init_injection_classifier();
+  init_parser();
   init_engine();
   init_merger();
   init_scope();
@@ -16822,6 +16829,7 @@ var init_agent = __esm(() => {
   init_jikji_find_tool();
   init_local_model();
   init_peer_target_tool();
+  init_refresh_progress();
   init_search_all_tool();
   init_search_documents();
   init_search_minsync_tool();
@@ -17002,7 +17010,7 @@ ${this.description}`
 }
 
 // src/datasource/skills/clawgallery/client.ts
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { existsSync as existsSync18 } from "node:fs";
 
 class ClawGalleryClient {
@@ -17107,7 +17115,7 @@ class ClawGalleryClient {
 function spawnCli(binary, args, env, options, signal) {
   return new Promise((resolve) => {
     const portable = portableSpawnCommand(binary, args);
-    const child = spawn7(portable.command, [...portable.args], { env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn8(portable.command, [...portable.args], { env, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     let settled = false;
@@ -17626,10 +17634,10 @@ function resolveToken(token, tokenEnv) {
 var DEFAULT_TIMEOUT_MS6 = 15000;
 
 // src/datasource/skills/cloud-drive/rclone-connector.ts
-import { spawn as spawn8 } from "node:child_process";
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync13, renameSync as renameSync7, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "node:fs";
-import { readFile as readFile6 } from "node:fs/promises";
-import { dirname as dirname13, join as join23, normalize as normalize3 } from "node:path";
+import { spawn as spawn9 } from "node:child_process";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync14, renameSync as renameSync8, rmSync as rmSync5, writeFileSync as writeFileSync12 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
+import { dirname as dirname14, join as join22, normalize as normalize3 } from "node:path";
 
 class RcloneConnector {
   options;
@@ -17716,18 +17724,18 @@ class RcloneConnector {
         return;
       const destination = mirrorFilePath(paths.mirrorRoot, entry.path);
       const temp = `${destination}.autorag-tmp`;
-      mkdirSync12(dirname13(temp), { recursive: true });
+      mkdirSync13(dirname14(temp), { recursive: true });
       let copied;
       try {
         copied = await this.runner(copyArgs(remote, entry.path, temp, exportFormats, this.options.concurrency, this.options.bandwidthLimit), timeoutMs);
       } catch {
         copyFailure = { reason: "unavailable", message: "rclone copy failed unexpectedly" };
-        rmSync4(temp, { force: true });
+        rmSync5(temp, { force: true });
         return;
       }
       if (!copied.ok) {
         copyFailure = { reason: classifyFailure(copied.stderr), message: shortFailure(copied) };
-        rmSync4(temp, { force: true });
+        rmSync5(temp, { force: true });
         return;
       }
       staged.push({ temp, destination });
@@ -17737,13 +17745,13 @@ class RcloneConnector {
     await Promise.all(Array.from({ length: concurrency }, () => copyOne()));
     if (copyFailure !== undefined) {
       for (const file of staged)
-        rmSync4(file.temp, { force: true });
+        rmSync5(file.temp, { force: true });
       return { ok: false, reason: copyFailure.reason, message: copyFailure.message };
     }
     for (const file of staged)
-      renameSync7(file.temp, file.destination);
+      renameSync8(file.temp, file.destination);
     for (const entry of deletedEntries)
-      rmSync4(mirrorFilePath(paths.mirrorRoot, entry.path), { force: true });
+      rmSync5(mirrorFilePath(paths.mirrorRoot, entry.path), { force: true });
     saveManifest(paths.manifestPath, { version: 1, remoteName: remoteName(remote), entries: inventory });
     const mirrorWarnings = await loadMirroredDocuments(paths.mirrorRoot, changedEntries, skillName, instanceId, remote, this.options.parserOptions);
     const warnings = [
@@ -17821,12 +17829,12 @@ function sameEntry(previous, current) {
   return previous?.path === current.path && previous.size === current.size && previous.modTime === current.modTime && previous.remoteId === current.remoteId && JSON.stringify(previous.hashes) === JSON.stringify(current.hashes);
 }
 function mirrorPaths(workspaceRoot, skillName, instanceId) {
-  const base = join23(workspaceRoot, ".autorag", "datasources", skillName, instanceId);
-  return { mirrorRoot: join23(base, "mirror"), manifestPath: join23(base, "manifest.json") };
+  const base = join22(workspaceRoot, ".autorag", "datasources", skillName, instanceId);
+  return { mirrorRoot: join22(base, "mirror"), manifestPath: join22(base, "manifest.json") };
 }
 function mirrorFilePath(root, path) {
   const safe = normalize3(path).replace(/^(\.\.(?:[/\\]|$))+|^[/\\]+/gu, "");
-  return join23(root, safe);
+  return join22(root, safe);
 }
 function remoteTarget(remote, path) {
   return remote.endsWith(":") || remote.endsWith("/") ? `${remote}${path}` : `${remote}/${path}`;
@@ -17845,18 +17853,18 @@ function copyArgs(remote, path, destination, exportFormats, concurrency, bandwid
 }
 function loadManifest2(path) {
   try {
-    const parsed = JSON.parse(readFileSync13(path, "utf8"));
+    const parsed = JSON.parse(readFileSync14(path, "utf8"));
     return parsed.version === 1 && Array.isArray(parsed.entries) ? parsed : undefined;
   } catch {
     return;
   }
 }
 function saveManifest(path, manifest) {
-  mkdirSync12(dirname13(path), { recursive: true });
+  mkdirSync13(dirname14(path), { recursive: true });
   const temp = `${path}.autorag-tmp`;
-  writeFileSync11(temp, `${JSON.stringify(manifest)}
+  writeFileSync12(temp, `${JSON.stringify(manifest)}
 `, "utf8");
-  renameSync7(temp, path);
+  renameSync8(temp, path);
 }
 async function loadMirroredDocuments(root, entries, skillName, instanceId, remote, parserOptions) {
   const documents = [];
@@ -17869,7 +17877,7 @@ async function loadMirroredDocuments(root, entries, skillName, instanceId, remot
       const parser = registry.getForVirtualPath(entry.path);
       if (parser === undefined)
         continue;
-      const bytes = await readFile6(sourcePath);
+      const bytes = await readFile4(sourcePath);
       const parsed = await parser.parse({ virtualPath: entry.path, sourcePath, bytes });
       for (const diagnostic of parsed.diagnostics ?? []) {
         warnings.push(`${diagnostic.code}: ${diagnostic.message}`);
@@ -17930,7 +17938,7 @@ function shortFailure(result) {
 function runBinary(binary, args, timeoutMs, env, cwd) {
   return new Promise((resolvePromise) => {
     const portable = portableSpawnCommand(binary, args);
-    const child = spawn8(portable.command, [...portable.args], {
+    const child = spawn9(portable.command, [...portable.args], {
       ...env === undefined ? {} : { env: { ...process.env, ...env } },
       ...cwd === undefined ? {} : { cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -18004,10 +18012,10 @@ function sanitizeIdSegment(value) {
 var init_connector = () => {};
 
 // src/datasource/chunk-store.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname14, join as join24 } from "node:path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname15, join as join23 } from "node:path";
 function datasourceChunkStorePath(workspaceRoot, skillName, instanceId) {
-  return join24(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId), "chunks.json");
+  return join23(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId), "chunks.json");
 }
 
 class DatasourceChunkStore {
@@ -18046,7 +18054,7 @@ class DatasourceChunkStore {
     try {
       if (!existsSync19(this.storePath))
         return false;
-      const parsed = JSON.parse(readFileSync14(this.storePath, "utf8"));
+      const parsed = JSON.parse(readFileSync15(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");
@@ -18120,7 +18128,7 @@ class DatasourceChunkStore {
     if (this.storePath === undefined)
       return;
     try {
-      mkdirSync13(dirname14(this.storePath), { recursive: true });
+      mkdirSync14(dirname15(this.storePath), { recursive: true });
       const payload = {
         version: STORE_VERSION,
         skill: this.skillName,
@@ -18128,7 +18136,7 @@ class DatasourceChunkStore {
         updatedAt: Date.now(),
         chunks: this.chunkList
       };
-      writeFileSync12(this.storePath, `${JSON.stringify(payload)}
+      writeFileSync13(this.storePath, `${JSON.stringify(payload)}
 `, "utf8");
     } catch {}
   }
@@ -18543,13 +18551,13 @@ var init_cloud_drive = __esm(() => {
 });
 
 // src/process/terminate-tree.ts
-import { spawn as spawn9 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 function terminateProcessTree(child, signal = "SIGKILL") {
   const pid = child.pid;
   if (pid === undefined)
     return false;
   if (process.platform === "win32") {
-    const killer = spawn9("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
+    const killer = spawn10("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
     killer.on("error", () => killDirectChild(child, signal));
     killer.on("close", (code) => {
       if (code !== 0)
@@ -18592,9 +18600,9 @@ var init_types4 = __esm(() => {
 });
 
 // src/datasource/skills/discrawl/client.ts
-import { spawn as spawn10 } from "node:child_process";
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname15 } from "node:path";
+import { spawn as spawn11 } from "node:child_process";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname16 } from "node:path";
 
 class DiscrawlClient {
   options;
@@ -18610,7 +18618,7 @@ class DiscrawlClient {
     const path = `${workspace}/.autorag/datasources/discrawl/config.toml`;
     let existing = "";
     try {
-      existing = readFileSync15(path, "utf8");
+      existing = readFileSync16(path, "utf8");
     } catch {}
     const managed = existing.startsWith(`# AutoRAG managed discrawl embeddings v1
 `);
@@ -18618,9 +18626,9 @@ class DiscrawlClient {
       return { configured: false, rebuildRequired: false };
     const previous = managed ? parseManagedEmbedding(existing) : undefined;
     const config = managedDiscrawlConfig({ ...runtime, baseUrl: nativeGatewayBaseUrl(runtime.baseUrl) });
-    mkdirSync14(dirname15(path), { recursive: true });
+    mkdirSync15(dirname16(path), { recursive: true });
     if (existing !== config)
-      writeFileSync13(path, config, "utf8");
+      writeFileSync14(path, config, "utf8");
     return {
       configured: true,
       rebuildRequired: previous !== undefined && (previous.provider !== runtime.provider || previous.model !== runtime.model || previous.dimensions !== runtime.dimensions)
@@ -18732,7 +18740,7 @@ function spawnDiscrawl(request) {
   return new Promise((resolveResult) => {
     const { options, args, env, signal } = request;
     const portable = portableSpawnCommand(options.binaryPath ?? DEFAULT_DISCRAWL_BINARY, args);
-    const child = spawn10(portable.command, [...portable.args], {
+    const child = spawn11(portable.command, [...portable.args], {
       env,
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       detached: process.platform !== "win32",
@@ -19642,8 +19650,8 @@ var init_github = __esm(() => {
 
 // src/datasource/skills/github-gist/connector.ts
 import { execFile as execFile3 } from "node:child_process";
-import { existsSync as existsSync20, mkdirSync as mkdirSync15, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname16 } from "node:path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync16, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname17 } from "node:path";
 async function defaultGhTokenRunner() {
   return new Promise((resolve) => {
     execFile3("gh", ["auth", "token"], { timeout: GH_TOKEN_TIMEOUT_MS }, (error, stdout) => {
@@ -19765,7 +19773,7 @@ class GitHubGistConnector {
     if (statePath === undefined || !existsSync20(statePath))
       return { version: STATE_VERSION, gists: {} };
     try {
-      const parsed = JSON.parse(readFileSync16(statePath, "utf8"));
+      const parsed = JSON.parse(readFileSync17(statePath, "utf8"));
       if (parsed.version !== STATE_VERSION || typeof parsed.gists !== "object" || parsed.gists === null) {
         return { version: STATE_VERSION, gists: {} };
       }
@@ -19779,8 +19787,8 @@ class GitHubGistConnector {
     if (statePath === undefined)
       return;
     try {
-      mkdirSync15(dirname16(statePath), { recursive: true });
-      writeFileSync14(statePath, `${JSON.stringify(state)}
+      mkdirSync16(dirname17(statePath), { recursive: true });
+      writeFileSync15(statePath, `${JSON.stringify(state)}
 `, "utf8");
     } catch {}
   }
@@ -19825,8 +19833,8 @@ var init_connector3 = () => {};
 
 // src/datasource/skills/github-gist/semantic.ts
 import { createHash as createHash7 } from "node:crypto";
-import { existsSync as existsSync21, mkdirSync as mkdirSync16, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname17 } from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync17, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "node:fs";
+import { dirname as dirname18 } from "node:path";
 function contentHash(chunk) {
   return createHash7("sha256").update(`${chunk.title ?? ""}
 ${chunk.content}`).digest("hex");
@@ -19919,7 +19927,7 @@ ${chunk.content}`));
     if (this.statePath === undefined || !existsSync21(this.statePath))
       return;
     try {
-      const parsed = JSON.parse(readFileSync17(this.statePath, "utf8"));
+      const parsed = JSON.parse(readFileSync18(this.statePath, "utf8"));
       if (parsed.version !== VECTORS_VERSION || typeof parsed.entries !== "object" || parsed.entries === null)
         return;
       if (typeof parsed.identity?.dimension !== "number")
@@ -19934,13 +19942,13 @@ ${chunk.content}`));
     if (this.identity === undefined)
       return;
     try {
-      mkdirSync16(dirname17(this.statePath), { recursive: true });
+      mkdirSync17(dirname18(this.statePath), { recursive: true });
       const payload = {
         version: VECTORS_VERSION,
         identity: this.identity,
         entries: this.entries
       };
-      writeFileSync15(this.statePath, `${JSON.stringify(payload)}
+      writeFileSync16(this.statePath, `${JSON.stringify(payload)}
 `, "utf8");
     } catch {}
   }
@@ -20074,9 +20082,9 @@ var init_semantic = __esm(() => {
 });
 
 // src/datasource/skills/github-gist/skill.ts
-import { join as join25 } from "node:path";
+import { join as join24 } from "node:path";
 function gistDatasourceDir(workspaceRoot, skillName, instanceId) {
-  return join25(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId));
+  return join24(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId));
 }
 var GITHUB_GIST_SKILL_DEFINITION, DEFAULT_INSTANCE_ID3 = "default", GitHubGistSkill;
 var init_skill5 = __esm(() => {
@@ -20104,7 +20112,7 @@ var init_skill5 = __esm(() => {
     constructor(options = {}) {
       const { connector, connectorOptions, semantic, ...rest } = options;
       const instanceId = options.instanceId ?? DEFAULT_INSTANCE_ID3;
-      const statePath = connectorOptions?.statePath ?? (options.workspaceRoot === undefined ? undefined : join25(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "state.json"));
+      const statePath = connectorOptions?.statePath ?? (options.workspaceRoot === undefined ? undefined : join24(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "state.json"));
       super(GITHUB_GIST_SKILL_DEFINITION, {
         ...rest,
         connector: connector ?? new GitHubGistConnector({
@@ -20114,7 +20122,7 @@ var init_skill5 = __esm(() => {
       });
       if (semantic?.enabled !== false) {
         this.semanticIndex = new GistSemanticIndex({
-          statePath: semantic?.statePath ?? (options.workspaceRoot === undefined ? undefined : join25(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "vectors.json"))
+          statePath: semantic?.statePath ?? (options.workspaceRoot === undefined ? undefined : join24(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "vectors.json"))
         });
         this.semanticEmbedder = semantic?.embedder ?? createGatewayGistEmbedder(semantic?.embedderOptions ?? {});
         this.semanticMethod = new GitHubGistSemanticMethod({
@@ -20164,7 +20172,7 @@ var init_github_gist = __esm(() => {
 });
 
 // src/datasource/crawler-client.ts
-import { spawn as spawn11 } from "node:child_process";
+import { spawn as spawn12 } from "node:child_process";
 
 class CrawlerCliClient {
   profile;
@@ -20201,7 +20209,7 @@ class CrawlerCliClient {
 function spawnCrawler(command, args, env, signal, options, cwd) {
   return new Promise((resolve) => {
     const portable = portableSpawnCommand(command, args);
-    const child = spawn11(portable.command, [...portable.args], {
+    const child = spawn12(portable.command, [...portable.args], {
       env,
       ...cwd === undefined ? {} : { cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -20414,7 +20422,7 @@ function parseMessages(stdout) {
     return;
   const hits = [];
   for (const row of rows) {
-    if (!isRecord12(row))
+    if (!isRecord14(row))
       return;
     const id = scalarString(row.message_id);
     const content = scalarString(row.content);
@@ -20447,9 +20455,9 @@ function parseDocs(stdout) {
     return;
   const hits = [];
   for (const row of rows) {
-    if (!isRecord12(row))
+    if (!isRecord14(row))
       return;
-    const meta = isRecord12(row.result_meta) ? row.result_meta : {};
+    const meta = isRecord14(row.result_meta) ? row.result_meta : {};
     const token = firstString(meta, ["token", "docs_token"]) ?? firstString(row, ["token", "docs_token"]) ?? tokenFromUrl(firstString(meta, ["url"]));
     const content = stripHighlight(firstString(row, ["summary_highlighted", "title_highlighted", "summary", "title"]) ?? "");
     if (token === undefined || !isSafeId(token) || content.length === 0)
@@ -20480,7 +20488,7 @@ function envelopeData(stdout) {
   } catch {
     return;
   }
-  if (!isRecord12(parsed) || parsed.ok !== true || !isRecord12(parsed.data))
+  if (!isRecord14(parsed) || parsed.ok !== true || !isRecord14(parsed.data))
     return;
   return parsed.data;
 }
@@ -20513,7 +20521,7 @@ function stripHighlight(value) {
 function isSafeId(value) {
   return value.length > 0 && value !== "." && value !== ".." && !value.includes("#") && !value.includes("/");
 }
-function isRecord12(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isRateLimited(failure) {
@@ -20828,9 +20836,9 @@ var init_types5 = __esm(() => {
 });
 
 // src/datasource/skills/lazykatok/client.ts
-import { spawn as spawn12 } from "node:child_process";
+import { spawn as spawn13 } from "node:child_process";
 import { existsSync as existsSync22 } from "node:fs";
-import { delimiter as delimiter4, join as join26 } from "node:path";
+import { delimiter as delimiter4, join as join25 } from "node:path";
 
 class LazykatokClient {
   options;
@@ -20924,7 +20932,7 @@ function spawnLazykatok(request) {
   return new Promise((resolve) => {
     const { options, args, env, signal } = request;
     const portable = portableSpawnCommand(commandFor2(options, env), args);
-    const child = spawn12(portable.command, [...portable.args], {
+    const child = spawn13(portable.command, [...portable.args], {
       env,
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       detached: process.platform !== "win32",
@@ -21014,7 +21022,7 @@ function lookupInPath2(executable, env) {
   for (const dir of pathEnv.split(delimiter4)) {
     if (dir.length === 0)
       continue;
-    const candidate = join26(dir, executable);
+    const candidate = join25(dir, executable);
     if (existsSync22(candidate))
       return candidate;
   }
@@ -21502,8 +21510,8 @@ var init_lazykatok = __esm(() => {
 });
 
 // src/datasource/skills/mail-export/connector.ts
-import { readdir as readdir2, readFile as readFile7, stat as stat5 } from "node:fs/promises";
-import { basename as basename10, dirname as dirname18, extname as extname9, join as join27 } from "node:path";
+import { readdir as readdir2, readFile as readFile5, stat as stat5 } from "node:fs/promises";
+import { basename as basename9, dirname as dirname19, extname as extname7, join as join26 } from "node:path";
 import { simpleParser as simpleParser2 } from "mailparser";
 
 class MailExportConnector {
@@ -21527,9 +21535,9 @@ class MailExportConnector {
           for (const entry of entries) {
             if (!entry.isFile())
               continue;
-            const extension = extname9(entry.name).toLowerCase();
+            const extension = extname7(entry.name).toLowerCase();
             if (extension === ".eml" || extension === ".mbox") {
-              files.push(join27(entry.parentPath, entry.name));
+              files.push(join26(entry.parentPath, entry.name));
             }
           }
         } else if (info.isFile()) {
@@ -21558,15 +21566,15 @@ class MailExportConnector {
           skippedLarge += 1;
           continue;
         }
-        bytes = await readFile7(file);
+        bytes = await readFile5(file);
       } catch {
         parseFailures += 1;
         continue;
       }
-      const stem = basename10(file, extname9(file));
-      const mailboxDir = basename10(dirname18(file));
+      const stem = basename9(file, extname7(file));
+      const mailboxDir = basename9(dirname19(file));
       const hierarchy = ["mailboxes", mailboxDir, stem];
-      const extension = extname9(file).toLowerCase();
+      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)
@@ -21674,21 +21682,21 @@ var init_mail_export = __esm(() => {
 });
 
 // src/datasource/skills/mailcrawl/config.ts
-import { chmodSync, mkdirSync as mkdirSync17 } from "node:fs";
+import { chmodSync, mkdirSync as mkdirSync18 } from "node:fs";
 function validateMailcrawlInstanceId(instanceId) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(instanceId)) {
     throw new Error("mailcrawl instanceId must be a safe single path segment");
   }
 }
 function ensurePrivateMailcrawlDataDir(path) {
-  mkdirSync17(path, { recursive: true, mode: 448 });
+  mkdirSync18(path, { recursive: true, mode: 448 });
   if (process.platform !== "win32")
     chmodSync(path, 448);
 }
 var init_config = () => {};
 
 // src/datasource/skills/mailcrawl/client.ts
-import { spawn as spawn13 } from "node:child_process";
+import { spawn as spawn14 } from "node:child_process";
 
 class MailcrawlClient {
   options;
@@ -21808,7 +21816,7 @@ class MailcrawlClient {
 function spawnMailcrawl(binary, args, env, options, signal, timeoutMs) {
   return new Promise((resolveResult) => {
     const portable = portableSpawnCommand(binary, args);
-    const child = spawn13(portable.command, portable.args, {
+    const child = spawn14(portable.command, portable.args, {
       env,
       detached: process.platform !== "win32",
       stdio: ["ignore", "pipe", "pipe"]
@@ -22504,7 +22512,7 @@ function parseCount(stdout) {
     return;
   if (Array.isArray(parsed))
     return parsed.length;
-  if (!isRecord13(parsed))
+  if (!isRecord15(parsed))
     return;
   for (const key of ["pages", "page_count", "pageCount", "synced", "count"]) {
     const value = parsed[key];
@@ -22519,12 +22527,12 @@ function parseHits(stdout) {
     return parseTabSeparatedHits(trimmed);
   }
   const parsed = parseJson4(stdout);
-  const rows = Array.isArray(parsed) ? parsed : isRecord13(parsed) && Array.isArray(parsed.results) ? parsed.results : undefined;
+  const rows = Array.isArray(parsed) ? parsed : isRecord15(parsed) && Array.isArray(parsed.results) ? parsed.results : undefined;
   if (rows === undefined)
     return;
   const hits = [];
   for (const [index, row] of rows.entries()) {
-    if (!isRecord13(row))
+    if (!isRecord15(row))
       return;
     const id = stringValue2(row, ["page_id", "id"]);
     const content = stringValue2(row, ["snippet", "text", "content"]);
@@ -22588,7 +22596,7 @@ function parseJson4(stdout) {
     return;
   }
 }
-function isRecord13(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringValue2(record, keys) {
@@ -22638,15 +22646,15 @@ var init_notion = __esm(() => {
 });
 
 // src/datasource/skills/obsidian/paths.ts
-import { join as join28 } from "node:path";
+import { join as join27 } from "node:path";
 function obsidianDatasourceRoot(workspaceRoot, instanceId) {
-  return join28(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, OBSIDIAN_DATASOURCE_DIRNAME, instanceId);
+  return join27(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, OBSIDIAN_DATASOURCE_DIRNAME, instanceId);
 }
 function obsidianQmdConfigDir(workspaceRoot, instanceId) {
-  return join28(obsidianDatasourceRoot(workspaceRoot, instanceId), "config");
+  return join27(obsidianDatasourceRoot(workspaceRoot, instanceId), "config");
 }
 function obsidianQmdCacheDir(workspaceRoot, instanceId) {
-  return join28(obsidianDatasourceRoot(workspaceRoot, instanceId), "cache");
+  return join27(obsidianDatasourceRoot(workspaceRoot, instanceId), "cache");
 }
 function stripEdgeDashes(value) {
   let start = 0;
@@ -22668,8 +22676,8 @@ var init_paths5 = () => {};
 var DEFAULT_QMD_BINARY = "qmd", DEFAULT_QMD_TIMEOUT_MS = 60000, DEFAULT_QMD_MAX_BUFFER_BYTES = 1048576;
 
 // src/datasource/skills/obsidian/client.ts
-import { spawn as spawn14 } from "node:child_process";
-import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync16 } from "node:fs";
+import { spawn as spawn15 } from "node:child_process";
+import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync17 } from "node:fs";
 import { isAbsolute as isAbsolute6, resolve as resolve12 } from "node:path";
 
 class QmdClient {
@@ -22689,10 +22697,10 @@ class QmdClient {
     const cacheDir = obsidianQmdCacheDir(workspaceRoot, instanceId);
     try {
       if (this.options.configPath === undefined) {
-        mkdirSync18(configDir, { recursive: true });
-        writeFileSync16(resolve12(configDir, "index.yml"), renderIndexYaml(collectionName, vaultPath), "utf8");
+        mkdirSync19(configDir, { recursive: true });
+        writeFileSync17(resolve12(configDir, "index.yml"), renderIndexYaml(collectionName, vaultPath), "utf8");
       }
-      mkdirSync18(cacheDir, { recursive: true });
+      mkdirSync19(cacheDir, { recursive: true });
     } catch (error) {
       return failure3("spawn-error", error instanceof Error ? error.message : "failed to write qmd config");
     }
@@ -22793,7 +22801,7 @@ function isAllowedEnvKey2(key) {
 function spawnQmd(request) {
   return new Promise((resolveResult) => {
     const portable = portableSpawnCommand(request.binaryPath ?? DEFAULT_QMD_BINARY, request.args);
-    const child = spawn14(portable.command, [...portable.args], {
+    const child = spawn15(portable.command, [...portable.args], {
       env: request.env,
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       detached: process.platform !== "win32",
@@ -22915,7 +22923,7 @@ ${stderr}`;
   }
   try {
     const parsed = JSON.parse(stdout);
-    if (isRecord14(parsed)) {
+    if (isRecord16(parsed)) {
       return {
         indexed: numberField(parsed, "indexed") ?? numberField(parsed, "new") ?? 0,
         updated: numberField(parsed, "updated") ?? 0,
@@ -22944,7 +22952,7 @@ function parseSearchHits(stdout) {
 function extractHitRows(parsed) {
   if (Array.isArray(parsed))
     return parsed;
-  if (!isRecord14(parsed))
+  if (!isRecord16(parsed))
     return;
   for (const key of ["results", "hits", "documents", "items"]) {
     const value = parsed[key];
@@ -22956,7 +22964,7 @@ function extractHitRows(parsed) {
   return;
 }
 function normalizeHit3(raw) {
-  if (!isRecord14(raw))
+  if (!isRecord16(raw))
     return;
   const score = numberField(raw, "score") ?? numberField(raw, "relevance") ?? 0;
   const docid = stringField(raw, "docid") ?? stringField(raw, "id");
@@ -23002,7 +23010,7 @@ function numberField(record, key) {
   const value = record[key];
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
-function isRecord14(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var SAFE_INHERITED_ENV_KEYS3, SAFE_QMD_ENV_PREFIX = "QMD_";
@@ -23529,7 +23537,7 @@ function parseCount2(stdout) {
     return;
   if (Array.isArray(parsed))
     return parsed.length;
-  if (!isRecord15(parsed))
+  if (!isRecord17(parsed))
     return;
   for (const key of ["messages", "message_count", "messageCount", "synced", "count"]) {
     const value = parsed[key];
@@ -23542,12 +23550,12 @@ function parseHits2(stdout) {
   const parsed = parseJson5(stdout);
   if (parsed === null)
     return [];
-  const rows = Array.isArray(parsed) ? parsed : isRecord15(parsed) && Array.isArray(parsed.messages) ? parsed.messages : undefined;
+  const rows = Array.isArray(parsed) ? parsed : isRecord17(parsed) && Array.isArray(parsed.messages) ? parsed.messages : undefined;
   if (rows === undefined)
     return;
   const hits = [];
   for (const [index, row] of rows.entries()) {
-    if (!isRecord15(row))
+    if (!isRecord17(row))
       return;
     const workspaceId = stringValue3(row, ["workspace_id"]);
     const workspaceName = stringValue3(row, ["workspace_name"]);
@@ -23602,7 +23610,7 @@ function parseJson5(stdout) {
     return;
   }
 }
-function isRecord15(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringValue3(record, keys) {
@@ -23665,10 +23673,10 @@ var init_slack = __esm(() => {
 });
 
 // src/datasource/skills/spotlight/connector.ts
-import { spawn as spawn15 } from "node:child_process";
+import { spawn as spawn16 } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
 import { readFile as fsReadFile, stat as stat6 } from "node:fs/promises";
-import { basename as basename11, extname as extname10 } from "node:path";
+import { basename as basename10, extname as extname8 } from "node:path";
 
 class SpotlightConnector {
   options;
@@ -23752,10 +23760,10 @@ class SpotlightConnector {
         documents.push({
           docId: createHash8("sha256").update(path).digest("hex").slice(0, 16),
           hierarchy: ["files"],
-          title: basename11(path),
+          title: basename10(path),
           content,
           publishedAt: info.mtimeMs,
-          metadata: { path, extension: extname10(path).toLowerCase() }
+          metadata: { path, extension: extname8(path).toLowerCase() }
         });
       } catch (error) {
         const code = error.code;
@@ -23784,7 +23792,7 @@ class SpotlightConnector {
   }
 }
 var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS5 = 300, DEFAULT_MAX_BYTES_PER_FILE3, DEFAULT_TIMEOUT_MS9 = 15000, MAX_CONTENT_CHARS3 = 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((resolve) => {
-  const child = spawn15(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
+  const child = spawn16(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
   let stdout = "";
   let stderr = "";
   let settled = false;
@@ -23880,7 +23888,7 @@ function parseCount3(stdout) {
     return;
   if (Array.isArray(parsed))
     return parsed.length;
-  if (!isRecord16(parsed))
+  if (!isRecord18(parsed))
     return;
   for (const key of ["messages", "message_count", "messageCount", "imported", "count"]) {
     const value = parsed[key];
@@ -23893,12 +23901,12 @@ function parseHits3(stdout) {
   const parsed = parseJson6(stdout);
   if (parsed === null)
     return [];
-  const rows = Array.isArray(parsed) ? parsed : isRecord16(parsed) && Array.isArray(parsed.messages) ? parsed.messages : undefined;
+  const rows = Array.isArray(parsed) ? parsed : isRecord18(parsed) && Array.isArray(parsed.messages) ? parsed.messages : undefined;
   if (rows === undefined)
     return;
   const hits = [];
   for (const [index, row] of rows.entries()) {
-    if (!isRecord16(row))
+    if (!isRecord18(row))
       return;
     const id = stringValue4(row, ["message_id", "event_id", "id"]);
     const content = stringValue4(row, ["snippet", "text", "content"]);
@@ -23937,7 +23945,7 @@ function parseJson6(stdout) {
     return;
   }
 }
-function isRecord16(value) {
+function isRecord18(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringValue4(record, keys) {
@@ -24000,7 +24008,7 @@ function parseCount4(stdout) {
     return;
   if (Array.isArray(parsed))
     return parsed.length;
-  if (!isRecord17(parsed))
+  if (!isRecord19(parsed))
     return;
   for (const key of ["messages", "message_count", "messageCount", "imported", "count"]) {
     const value = parsed[key];
@@ -24013,12 +24021,12 @@ function parseHits4(stdout) {
   const parsed = parseJson7(stdout);
   if (parsed === null)
     return [];
-  const rows = Array.isArray(parsed) ? parsed : isRecord17(parsed) && Array.isArray(parsed.messages) ? parsed.messages : undefined;
+  const rows = Array.isArray(parsed) ? parsed : isRecord19(parsed) && Array.isArray(parsed.messages) ? parsed.messages : undefined;
   if (rows === undefined)
     return;
   const hits = [];
   for (const [index, row] of rows.entries()) {
-    if (!isRecord17(row))
+    if (!isRecord19(row))
       return;
     const id = stringValue5(row, ["message_id", "event_id", "id"]);
     const content = stringValue5(row, ["snippet", "text", "content"]);
@@ -24055,7 +24063,7 @@ function parseJson7(stdout) {
     return;
   }
 }
-function isRecord17(value) {
+function isRecord19(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringValue5(record, keys) {
@@ -24343,9 +24351,9 @@ var init_factory = __esm(() => {
 });
 
 // src/cli/config.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
-import { existsSync as existsSync23, mkdirSync as mkdirSync19, readFileSync as readFileSync18, renameSync as renameSync8, unlinkSync as unlinkSync4, writeFileSync as writeFileSync17 } from "node:fs";
-import { basename as basename12, dirname as dirname19, isAbsolute as isAbsolute7, join as join29, resolve as resolve13 } from "node:path";
+import { randomUUID as randomUUID8 } from "node:crypto";
+import { existsSync as existsSync23, mkdirSync as mkdirSync20, readFileSync as readFileSync19, renameSync as renameSync9, unlinkSync as unlinkSync4, writeFileSync as writeFileSync18 } from "node:fs";
+import { basename as basename11, dirname as dirname20, isAbsolute as isAbsolute7, join as join28, resolve as resolve13 } from "node:path";
 import { findEnvKeys, getEnvApiKey, getModel, getProviders } from "@earendil-works/pi-ai/compat";
 function resolveConfigPath(input) {
   const flags = input.flags;
@@ -24360,9 +24368,9 @@ function resolveConfigPath(input) {
     return { configPath: envConfig, explicit: true };
   }
   return {
-    configPath: join29(resolveAutoRAGHome(env), DEFAULT_CONFIG_FILENAME),
+    configPath: join28(resolveAutoRAGHome(env), DEFAULT_CONFIG_FILENAME),
     explicit: false,
-    legacyPath: join29(cwd, LEGACY_CONFIG_FILENAME)
+    legacyPath: join28(cwd, LEGACY_CONFIG_FILENAME)
   };
 }
 function readConfigFile(configPath, explicit) {
@@ -24380,7 +24388,7 @@ function readConfigFile(configPath, explicit) {
   }
   let text;
   try {
-    text = readFileSync18(configPath, "utf8");
+    text = readFileSync19(configPath, "utf8");
   } catch (err) {
     throw new ConfigError(`Failed to read config file: ${err.message}`);
   }
@@ -24418,11 +24426,11 @@ function acquireConfigWriteLock(configPath) {
   });
 }
 function replaceFileAtomically(path, contents, assertCommitAllowed) {
-  const temporaryPath = join29(dirname19(path), `.${basename12(path)}.${process.pid}.${randomUUID7()}.tmp`);
+  const temporaryPath = join28(dirname20(path), `.${basename11(path)}.${process.pid}.${randomUUID8()}.tmp`);
   try {
-    writeFileSync17(temporaryPath, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
+    writeFileSync18(temporaryPath, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
     assertCommitAllowed?.();
-    renameSync8(temporaryPath, path);
+    renameSync9(temporaryPath, path);
   } finally {
     removeFileIfPresent2(temporaryPath);
   }
@@ -24431,12 +24439,12 @@ function migrateLegacyConfig(configPath, legacyPath) {
   if (existsSync23(configPath) || !existsSync23(legacyPath))
     return;
   const legacy = readConfigFile(legacyPath, true);
-  const legacyBytes = readFileSync18(legacyPath);
-  const migrated = normalizeLegacyConfigPaths(legacy ?? {}, dirname19(legacyPath));
+  const legacyBytes = readFileSync19(legacyPath);
+  const migrated = normalizeLegacyConfigPaths(legacy ?? {}, dirname20(legacyPath));
   const migratedPathsUnchanged = legacy?.workspacePath === migrated.workspacePath && legacy?.memoryPath === migrated.memoryPath && JSON.stringify(legacy?.searchPaths) === JSON.stringify(migrated.searchPaths);
   const migratedBytes = migratedPathsUnchanged ? legacyBytes : `${JSON.stringify(migrated, null, 2)}
 `;
-  mkdirSync19(dirname19(configPath), { recursive: true });
+  mkdirSync20(dirname20(configPath), { recursive: true });
   const lock = acquireConfigWriteLock(configPath);
   try {
     const winner = readConfigFile(configPath, false);
@@ -24466,7 +24474,7 @@ function resolveConfigFileReadOnly(configPath, explicit, legacyPath) {
   const legacy = readConfigFile(legacyPath, false);
   if (legacy === undefined)
     return {};
-  return normalizeLegacyConfigPaths(legacy, dirname19(legacyPath));
+  return normalizeLegacyConfigPaths(legacy, dirname20(legacyPath));
 }
 function resolveSearchPaths(searchPaths, origin) {
   return searchPaths.map((searchPath) => resolvePersistedPath(searchPath, origin));
@@ -24501,6 +24509,15 @@ function envString(env, key) {
     return value;
   return;
 }
+function normalizeConfigLanguages(raw) {
+  try {
+    return normalizeLanguages(raw);
+  } catch (error) {
+    if (error instanceof LanguageError)
+      throw new ConfigError(error.message);
+    throw error;
+  }
+}
 function modelReference(value, path) {
   if (value === undefined)
     return;
@@ -24666,80 +24683,6 @@ function normalizeEmbedder(raw, path) {
   }
   return out;
 }
-function normalizeUiConfig(raw) {
-  if (raw === undefined || raw === null)
-    return {};
-  if (typeof raw !== "object" || Array.isArray(raw))
-    throw new ConfigError("Config field 'ui' must be an object");
-  const record = raw;
-  const allowed = new Set(["host", "port", "allowRemote", "publicOrigin", "corsOrigins", "tokenEnv"]);
-  for (const key of Object.keys(record)) {
-    if (!allowed.has(key))
-      throw new ConfigError(`ui.${key} is not a recognized field`);
-  }
-  const out = {};
-  if (record.host !== undefined) {
-    if (typeof record.host !== "string" || record.host.trim().length === 0) {
-      throw new ConfigError("ui.host must be a non-empty string");
-    }
-    out.host = record.host.trim();
-  }
-  if (record.port !== undefined) {
-    if (typeof record.port !== "number" || !Number.isInteger(record.port) || record.port < 0 || record.port > 65535) {
-      throw new ConfigError("ui.port must be an integer between 0 and 65535");
-    }
-    out.port = record.port;
-  }
-  if (record.allowRemote !== undefined) {
-    if (typeof record.allowRemote !== "boolean")
-      throw new ConfigError("ui.allowRemote must be a boolean");
-    out.allowRemote = record.allowRemote;
-  }
-  if (record.publicOrigin !== undefined) {
-    if (typeof record.publicOrigin !== "string" || record.publicOrigin.trim().length === 0) {
-      throw new ConfigError("ui.publicOrigin must be a non-empty origin");
-    }
-    let origin;
-    try {
-      origin = new URL(record.publicOrigin);
-    } catch {
-      throw new ConfigError("ui.publicOrigin must be a valid http(s) origin");
-    }
-    if (!["http:", "https:"].includes(origin.protocol) || origin.pathname !== "/" || origin.search || origin.hash) {
-      throw new ConfigError("ui.publicOrigin must be a valid http(s) origin");
-    }
-    out.publicOrigin = origin.origin;
-  }
-  if (record.corsOrigins !== undefined) {
-    if (!Array.isArray(record.corsOrigins))
-      throw new ConfigError("ui.corsOrigins must be an array of origins");
-    const origins = [];
-    for (const value of record.corsOrigins) {
-      if (typeof value !== "string" || value.trim().length === 0) {
-        throw new ConfigError("ui.corsOrigins must contain non-empty origins");
-      }
-      let origin;
-      try {
-        origin = new URL(value);
-      } catch {
-        throw new ConfigError("ui.corsOrigins must contain valid http(s) origins");
-      }
-      if (!["http:", "https:"].includes(origin.protocol) || origin.pathname !== "/" || origin.search || origin.hash) {
-        throw new ConfigError("ui.corsOrigins must contain valid http(s) origins");
-      }
-      if (!origins.includes(origin.origin))
-        origins.push(origin.origin);
-    }
-    out.corsOrigins = origins;
-  }
-  if (record.tokenEnv !== undefined) {
-    if (typeof record.tokenEnv !== "string" || !UI_TOKEN_ENV_PATTERN.test(record.tokenEnv)) {
-      throw new ConfigError("ui.tokenEnv must match /^[A-Za-z_][A-Za-z0-9_]*$/");
-    }
-    out.tokenEnv = record.tokenEnv;
-  }
-  return out;
-}
 function normalizeP2pConfig(raw) {
   const out = {};
   if (raw === undefined || raw === null) {
@@ -24911,10 +24854,10 @@ function resolveConfig(input) {
   const file = readOnly ? resolveConfigFileReadOnly(configPath, explicit, legacyPath) : !explicit && legacyPath ? migrateLegacyConfig(configPath, legacyPath) ?? readConfigFile(configPath, explicit) ?? {} : readConfigFile(configPath, explicit) ?? {};
   const defaultSearchPaths = ["."];
   const defaultWorkspacePath = cwd;
-  const defaultMemoryPath = join29(resolveAutoRAGHome(env), "memory.json");
+  const defaultMemoryPath = join28(resolveAutoRAGHome(env), "memory.json");
   const flagSearchPaths = parseCsv(flagString(flags, "search-paths"));
   const envSearchPaths = parseCsv(envString(env, "AUTORAG_SEARCH_PATHS"));
-  const configOrigin = dirname19(resolve13(configPath));
+  const configOrigin = dirname20(resolve13(configPath));
   const fileWorkspacePath = typeof file.workspacePath === "string" ? resolvePersistedPath(file.workspacePath, configOrigin) : undefined;
   const fileSearchPaths = file.searchPaths ? resolveSearchPaths(file.searchPaths, fileWorkspacePath ?? configOrigin) : undefined;
   const searchPaths = flagSearchPaths ?? envSearchPaths ?? fileSearchPaths ?? defaultSearchPaths;
@@ -24925,6 +24868,9 @@ function resolveConfig(input) {
   const envMemoryPath = envString(env, "AUTORAG_MEMORY_PATH");
   const fileMemoryPath = typeof file.memoryPath === "string" ? resolvePersistedPath(file.memoryPath, workspacePath) : undefined;
   const memoryPath = flagMemoryPath ?? envMemoryPath ?? fileMemoryPath ?? defaultMemoryPath;
+  const flagLanguages = typeof flags.languages === "string" ? flags.languages : undefined;
+  const envLanguages = env.AUTORAG_LANGUAGES;
+  const languages = flagLanguages !== undefined ? normalizeConfigLanguages(flagLanguages) : envLanguages !== undefined ? normalizeConfigLanguages(envLanguages) : normalizeConfigLanguages(file.languages);
   const fileModel = modelReference(file.model, "model");
   const flagModelProvider = pickString(flags, env, "model-provider", "AUTORAG_MODEL_PROVIDER", undefined);
   const flagModelId = pickString(flags, env, "model-id", "AUTORAG_MODEL_ID", undefined);
@@ -24932,7 +24878,8 @@ function resolveConfig(input) {
   const config = {
     searchPaths,
     workspacePath,
-    memoryPath
+    memoryPath,
+    languages
   };
   if (model)
     config.model = model;
@@ -24965,8 +24912,6 @@ function resolveConfig(input) {
     }
     config.datasourceAccess = file.datasourceAccess;
   }
-  if (file.ui !== undefined)
-    config.ui = normalizeUiConfig(file.ui);
   config.p2p = normalizeP2pConfig(file.p2p);
   return config;
 }
@@ -25028,7 +24973,8 @@ function buildWebSearchAgentOption(raw) {
 }
 function buildAgentOptions(config) {
   const opts = {
-    searchPaths: config.searchPaths
+    searchPaths: config.searchPaths,
+    languages: config.languages
   };
   if (config.workspacePath)
     opts.workspacePath = config.workspacePath;
@@ -25271,7 +25217,7 @@ function writeConfigObject(path, config) {
   if (config === null || typeof config !== "object" || Array.isArray(config)) {
     throw new ConfigError("Config file must be a JSON object");
   }
-  mkdirSync19(dirname19(path), { recursive: true });
+  mkdirSync20(dirname20(path), { recursive: true });
   const contents = `${JSON.stringify(config, null, 2)}
 `;
   const lock = acquireConfigWriteLock(path);
@@ -25284,11 +25230,12 @@ function writeConfigObject(path, config) {
 function writeDefaultConfig(path, partial, opts = {}) {
   const cwd = resolve13(opts.cwd ?? process.cwd());
   const workspacePath = resolvePersistedPath(partial.workspacePath ?? ".", cwd);
-  const memoryPath = partial.memoryPath === undefined ? join29(resolveAutoRAGHome(opts.env), "memory.json") : resolvePersistedPath(partial.memoryPath, workspacePath);
+  const memoryPath = partial.memoryPath === undefined ? join28(resolveAutoRAGHome(opts.env), "memory.json") : resolvePersistedPath(partial.memoryPath, workspacePath);
   const full = {
     searchPaths: resolveSearchPaths(partial.searchPaths ?? ["."], cwd),
     workspacePath,
-    memoryPath
+    memoryPath,
+    languages: normalizeConfigLanguages(partial.languages)
   };
   if (partial.model)
     full.model = partial.model;
@@ -25301,13 +25248,11 @@ function writeDefaultConfig(path, partial, opts = {}) {
   full.excludeExactDuplicates = partial.excludeExactDuplicates ?? true;
   if (partial.parserOptions)
     full.parserOptions = partial.parserOptions;
-  if (partial.ui !== undefined)
-    full.ui = normalizeUiConfig(partial.ui);
   if (partial.p2p !== undefined)
     full.p2p = normalizeP2pConfig(partial.p2p);
   else
     full.p2p = { enabled: false };
-  mkdirSync19(dirname19(path), { recursive: true });
+  mkdirSync20(dirname20(path), { recursive: true });
   const contents = `${JSON.stringify(full, null, 2)}
 `;
   const lock = acquireConfigWriteLock(path);
@@ -25319,7 +25264,7 @@ function writeDefaultConfig(path, partial, opts = {}) {
       replaceFileAtomically(path, contents, lock.assertOwned);
     else {
       lock.assertOwned();
-      writeFileSync17(path, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
+      writeFileSync18(path, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
     }
   } catch (error) {
     if (!opts.force && isEexistError(error)) {
@@ -25330,12 +25275,13 @@ function writeDefaultConfig(path, partial, opts = {}) {
     lock.release();
   }
 }
-var DEFAULT_CONFIG_FILENAME = "config.json", LEGACY_CONFIG_FILENAME = "autorag.config.json", CONFIG_LOCK_RETRY_MS = 10, CONFIG_LOCK_TIMEOUT_MS = 1e4, CONFIG_LOCK_STALE_MS = 30000, ConfigError, AGENT_MODEL_APIS, AGENT_MODEL_INPUTS, API_KEY_ENV_PATTERN2, POSITIVE_INT_FIELDS, EMBEDDER_ALLOWLIST, MINSYNC_ALLOWLIST, MINSYNC_LEGACY_IGNORED, UI_TOKEN_ENV_PATTERN, P2P_ALLOWLIST, P2P_QUOTA_ALLOWLIST;
+var DEFAULT_CONFIG_FILENAME = "config.json", LEGACY_CONFIG_FILENAME = "autorag.config.json", CONFIG_LOCK_RETRY_MS = 10, CONFIG_LOCK_TIMEOUT_MS = 1e4, CONFIG_LOCK_STALE_MS = 30000, ConfigError, AGENT_MODEL_APIS, AGENT_MODEL_INPUTS, API_KEY_ENV_PATTERN2, POSITIVE_INT_FIELDS, EMBEDDER_ALLOWLIST, MINSYNC_ALLOWLIST, MINSYNC_LEGACY_IGNORED, P2P_ALLOWLIST, P2P_QUOTA_ALLOWLIST;
 var init_config2 = __esm(() => {
   init_local_model();
   init_home();
   init_factory();
   init_file_lock();
+  init_language();
   init_types3();
   init_home();
   ConfigError = class ConfigError extends Error {
@@ -25376,7 +25322,6 @@ var init_config2 = __esm(() => {
     "embedder"
   ]);
   MINSYNC_LEGACY_IGNORED = new Set(["binaryPath"]);
-  UI_TOKEN_ENV_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
   P2P_ALLOWLIST = new Set([
     "enabled",
     "port",
@@ -25395,7 +25340,7 @@ var init_config2 = __esm(() => {
 });
 
 // src/core.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 
 class AutoRAGLite {
   config;
@@ -25448,7 +25393,7 @@ class AutoRAGLite {
     return recordStructuredResultsSession(sessionId, query, details, this.sessions, this.memory);
   }
   recordReport(query, details) {
-    return this.recordStructuredResultsSession(randomUUID8(), query, details);
+    return this.recordStructuredResultsSession(randomUUID9(), query, details);
   }
   getResultRegistry(sessionId) {
     return this.sessions.get(sessionId)?.registry ?? new Map;