@autorag/librarian 2.0.0 → 2.1.0

package/dist/cli/index.js

@@ -135,6 +135,8 @@ function searchEnvelope(resp, debug) {
       title: r.title,
       summary: r.summary
     };
+    if (r.source !== undefined)
+      base.source = r.source;
     if (debug) {
       base.confidence = r.confidence;
       base.evidence = r.evidence.map((e) => {
@@ -169,6 +171,8 @@ function renderSearchHuman(resp, debug) {
   for (const r of resp.results) {
     const header = `${r.number}. ${r.title}`;
     lines.push(header);
+    if (r.source !== undefined)
+      lines.push(`   source: ${r.source}`);
     if (r.summary)
       lines.push(`   ${r.summary}`);
     if (debug) {
@@ -356,20 +360,2671 @@ function resolveAutoRAGHome(env = process.env) {
 var AUTORAG_HOME_ENV = "AUTORAG_HOME";
 var init_home = () => {};
 
+// src/datasource/http.ts
+function combineSignals(timeoutMs, outer) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return outer === undefined ? timeout : AbortSignal.any([timeout, outer]);
+}
+function statusToReason(status) {
+  if (status === 401)
+    return "auth";
+  if (status === 403)
+    return "permission";
+  if (status === 429)
+    return "rate-limited";
+  return "api-error";
+}
+async function requestText(url, options) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      method: options.method ?? "GET",
+      headers: options.headers,
+      body: options.body,
+      signal: combineSignals(timeoutMs, options.signal)
+    });
+  } catch {
+    return { ok: false, reason: "unavailable", message: "request failed or timed out" };
+  }
+  if (!response.ok) {
+    return { ok: false, reason: statusToReason(response.status), message: `http-${response.status}` };
+  }
+  let text;
+  try {
+    text = await response.text();
+  } catch {
+    return { ok: false, reason: "invalid-data", message: "response body unreadable" };
+  }
+  return { ok: true, status: response.status, text };
+}
+function httpText(url, options = {}) {
+  return requestText(url, options);
+}
+async function httpJson(url, options = {}) {
+  const result = await requestText(url, options);
+  if (!result.ok)
+    return result;
+  try {
+    return { ok: true, status: result.status, json: JSON.parse(result.text) };
+  } catch {
+    return { ok: false, reason: "invalid-data", message: "response was not valid JSON" };
+  }
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function parseEpochMs(value) {
+  if (typeof value !== "string" || value.length === 0)
+    return;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
+function resolveToken(token, tokenEnv) {
+  if (token !== undefined && token.length > 0)
+    return token;
+  if (tokenEnv !== undefined && tokenEnv.length > 0) {
+    const fromEnv = process.env[tokenEnv];
+    if (fromEnv !== undefined && fromEnv.length > 0)
+      return fromEnv;
+  }
+  return;
+}
+var DEFAULT_TIMEOUT_MS = 15000;
+
+// src/datasource/skills/discord/connector.ts
+class DiscordConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV);
+    if (token === undefined)
+      return { ok: false, reason: "not-configured", message: "auth token not configured" };
+    const guildId = this.options.guildId;
+    if (guildId === undefined || guildId.length === 0) {
+      return { ok: false, reason: "not-configured", message: "guild id not configured" };
+    }
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL;
+    const request = {
+      headers: { Authorization: `Bot ${token}` },
+      timeoutMs: this.options.timeoutMs,
+      fetchImpl: this.options.fetchImpl,
+      signal
+    };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS;
+    const listResult = await httpJson(`${baseUrl}/guilds/${guildId}/channels`, request);
+    if (!listResult.ok) {
+      return { ok: false, reason: listResult.reason, message: `channel list failed: ${listResult.message}` };
+    }
+    const channels = [];
+    for (const raw of asArray(listResult.json)) {
+      const channel = asRecord(raw);
+      const id = asString(channel?.id);
+      const name = asString(channel?.name);
+      const type = asNumber(channel?.type);
+      if (id === undefined || name === undefined || type === undefined)
+        continue;
+      if (!TEXT_CHANNEL_TYPES.has(type))
+        continue;
+      channels.push({ id, name });
+    }
+    const filter = this.options.channels;
+    const selected = filter === undefined || filter.length === 0 ? channels : channels.filter((channel) => filter.includes(channel.id) || filter.includes(channel.name));
+    const documents = [];
+    const warnings = [];
+    for (const channel of selected) {
+      if (documents.length >= maxDocuments)
+        break;
+      let before;
+      for (let page = 0;page < maxPages && documents.length < maxDocuments; page += 1) {
+        const url = new URL(`${baseUrl}/channels/${channel.id}/messages`);
+        url.searchParams.set("limit", "100");
+        if (before !== undefined)
+          url.searchParams.set("before", before);
+        const result = await httpJson(url.toString(), request);
+        if (!result.ok) {
+          if (result.reason === "rate-limited") {
+            return { ok: false, reason: "rate-limited", message: "discord: rate limited" };
+          }
+          if (result.reason === "permission") {
+            warnings.push(`channel ${channel.name} skipped: missing permission`);
+          } else {
+            warnings.push(`channel ${channel.name} history failed: ${result.message}`);
+          }
+          break;
+        }
+        const messages = asArray(result.json);
+        if (messages.length === 0)
+          break;
+        let lastId;
+        for (const raw of messages) {
+          const message = asRecord(raw);
+          const id = asString(message?.id);
+          if (id !== undefined)
+            lastId = id;
+          if (documents.length >= maxDocuments)
+            continue;
+          const content = asString(message?.content);
+          if (message === undefined || id === undefined || content === undefined || content.length === 0)
+            continue;
+          const author = asString(asRecord(message.author)?.username) ?? "unknown";
+          documents.push({
+            docId: `${channel.id}-${id}`,
+            hierarchy: ["channels", channel.name],
+            title: `#${channel.name}`,
+            content: `${author}: ${content}`,
+            publishedAt: parseEpochMs(message.timestamp),
+            metadata: { channelId: channel.id, messageId: id, author }
+          });
+        }
+        if (lastId === undefined || messages.length < 100)
+          break;
+        before = lastId;
+      }
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+var DEFAULT_BASE_URL = "https://discord.com/api/v10", DEFAULT_TOKEN_ENV = "DISCORD_BOT_TOKEN", DEFAULT_MAX_PAGES = 10, DEFAULT_MAX_DOCUMENTS = 500, TEXT_CHANNEL_TYPES;
+var init_connector = __esm(() => {
+  TEXT_CHANNEL_TYPES = new Set([0, 5]);
+});
+
+// src/datasource/connector.ts
+import { createHash } from "node:crypto";
+function connectorFailureToDiagnosticCode(reason) {
+  switch (reason) {
+    case "auth":
+      return "datasource-auth-error";
+    case "permission":
+      return "datasource-permission-denied";
+    case "rate-limited":
+      return "datasource-rate-limited";
+    case "unavailable":
+    case "not-configured":
+      return "datasource-unavailable";
+    case "empty":
+      return "datasource-empty";
+    case "api-error":
+    case "invalid-data":
+      return "datasource-index-failed";
+  }
+}
+function boundDiagnosticText(value) {
+  const trimmed = value.trim();
+  return trimmed.length > 500 ? `${trimmed.slice(0, 500)}...` : trimmed;
+}
+function sanitizeIdSegment(value) {
+  const normalized = value.replace(/[^\p{L}\p{N}._-]+/gu, "-");
+  let start = 0;
+  while (start < normalized.length && (normalized[start] === "-" || normalized[start] === "."))
+    start += 1;
+  let end = normalized.length;
+  while (end > start && (normalized[end - 1] === "-" || normalized[end - 1] === "."))
+    end -= 1;
+  const cleaned = normalized.slice(start, end);
+  if (cleaned === value && cleaned.length > 0 && cleaned.length <= 80)
+    return cleaned;
+  const hash = createHash("sha256").update(value).digest("hex").slice(0, 8);
+  const stem = cleaned.slice(0, 60);
+  return stem.length > 0 ? `${stem}-${hash}` : hash;
+}
+var init_connector2 = () => {};
+
+// src/datasource/chunk-store.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+function datasourceChunkStorePath(workspaceRoot, skillName, instanceId) {
+  return join2(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId), "chunks.json");
+}
+
+class DatasourceChunkStore {
+  skillName;
+  instanceId;
+  storePath;
+  maxChunkChars;
+  chunkList = [];
+  loaded = false;
+  constructor(options) {
+    this.skillName = options.skillName;
+    this.instanceId = options.instanceId;
+    this.maxChunkChars = options.maxChunkChars ?? DEFAULT_MAX_CHUNK_CHARS;
+    this.storePath = options.workspaceRoot === undefined ? undefined : datasourceChunkStorePath(options.workspaceRoot, options.skillName, options.instanceId);
+  }
+  replaceDocuments(documents) {
+    const chunks = [];
+    const seenIds = new Set;
+    for (const document of documents) {
+      const docSegment = sanitizeIdSegment(document.docId);
+      const hierarchy = (document.hierarchy ?? []).map(sanitizeIdSegment).filter((segment) => segment.length > 0);
+      const parts = splitContent(document.content, this.maxChunkChars);
+      for (const [index, part] of parts.entries()) {
+        let chunkId = parts.length === 1 ? docSegment : `${docSegment}-p${index + 1}`;
+        while (seenIds.has(chunkId))
+          chunkId = `${chunkId}x`;
+        seenIds.add(chunkId);
+        chunks.push({
+          chunkId,
+          docId: document.docId,
+          hierarchy,
+          ...document.title !== undefined ? { title: document.title } : {},
+          content: part,
+          ...document.publishedAt !== undefined ? { publishedAt: document.publishedAt } : {},
+          metadata: { ...document.metadata ?? {} }
+        });
+      }
+    }
+    this.chunkList = chunks;
+    this.loaded = true;
+    this.persist();
+    return chunks.length;
+  }
+  load() {
+    if (this.storePath === undefined)
+      return false;
+    try {
+      if (!existsSync(this.storePath))
+        return false;
+      const parsed = JSON.parse(readFileSync(this.storePath, "utf8"));
+      if (parsed.version !== STORE_VERSION || !Array.isArray(parsed.chunks))
+        return false;
+      this.chunkList = parsed.chunks.filter((chunk) => typeof chunk?.chunkId === "string" && typeof chunk?.content === "string");
+      this.loaded = true;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  ensureLoaded() {
+    if (!this.loaded) {
+      this.load();
+      this.loaded = true;
+    }
+  }
+  chunks() {
+    this.ensureLoaded();
+    return this.chunkList;
+  }
+  hierarchies() {
+    this.ensureLoaded();
+    const seen = new Map;
+    for (const chunk of this.chunkList) {
+      seen.set(chunk.hierarchy.join("/"), chunk.hierarchy);
+    }
+    return [...seen.values()];
+  }
+  search(query, topK) {
+    this.ensureLoaded();
+    const queryTerms = [...new Set(tokenize(query))];
+    if (queryTerms.length === 0 || this.chunkList.length === 0 || topK <= 0)
+      return [];
+    const docCount = this.chunkList.length;
+    const tokenized = this.chunkList.map((chunk) => tokenize(`${chunk.title ?? ""} ${chunk.content}`));
+    const avgLength = tokenized.reduce((sum, tokens) => sum + tokens.length, 0) / docCount || 1;
+    const termFrequency = (term, tokens) => {
+      let tf = 0;
+      for (const token of tokens) {
+        if (token === term)
+          tf += 1;
+        else if (term.length >= 2 && token.startsWith(term))
+          tf += 0.75;
+      }
+      return tf;
+    };
+    const frequencies = queryTerms.map((term) => tokenized.map((tokens) => termFrequency(term, tokens)));
+    const documentFrequency = frequencies.map((perDoc) => perDoc.reduce((count, tf) => count + (tf > 0 ? 1 : 0), 0));
+    const k1 = 1.2;
+    const b = 0.75;
+    const scored = [];
+    for (const [index, chunk] of this.chunkList.entries()) {
+      const tokens = tokenized[index] ?? [];
+      let score = 0;
+      for (const [termIndex] of queryTerms.entries()) {
+        const df = documentFrequency[termIndex] ?? 0;
+        if (df === 0)
+          continue;
+        const tf = frequencies[termIndex]?.[index] ?? 0;
+        if (tf === 0)
+          continue;
+        const idf = Math.log(1 + (docCount - df + 0.5) / (df + 0.5));
+        score += idf * tf * (k1 + 1) / (tf + k1 * (1 - b + b * tokens.length / avgLength));
+      }
+      if (score > 0)
+        scored.push({ chunk, score });
+    }
+    scored.sort((a, b2) => b2.score - a.score || a.chunk.chunkId.localeCompare(b2.chunk.chunkId));
+    return scored.slice(0, topK);
+  }
+  persist() {
+    if (this.storePath === undefined)
+      return;
+    try {
+      mkdirSync(dirname(this.storePath), { recursive: true });
+      const payload = {
+        version: STORE_VERSION,
+        skill: this.skillName,
+        instance: this.instanceId,
+        updatedAt: Date.now(),
+        chunks: this.chunkList
+      };
+      writeFileSync(this.storePath, `${JSON.stringify(payload)}
+`, "utf8");
+    } catch {}
+  }
+}
+function splitContent(content, maxChars) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0)
+    return [];
+  if (trimmed.length <= maxChars)
+    return [trimmed];
+  const parts = [];
+  const paragraphs = trimmed.split(/\n{2,}/u);
+  let current = "";
+  for (const paragraph of paragraphs) {
+    if (current.length > 0 && current.length + paragraph.length + 2 > maxChars) {
+      parts.push(current);
+      current = "";
+    }
+    if (paragraph.length > maxChars) {
+      if (current.length > 0) {
+        parts.push(current);
+        current = "";
+      }
+      for (let offset = 0;offset < paragraph.length; offset += maxChars) {
+        parts.push(paragraph.slice(offset, offset + maxChars));
+      }
+      continue;
+    }
+    current = current.length === 0 ? paragraph : `${current}
+
+${paragraph}`;
+  }
+  if (current.length > 0)
+    parts.push(current);
+  return parts.filter((part) => part.trim().length > 0);
+}
+function tokenize(text) {
+  return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((token) => token.length > 0);
+}
+var STORE_VERSION = 1, DEFAULT_MAX_CHUNK_CHARS = 2000;
+var init_chunk_store = __esm(() => {
+  init_connector2();
+});
+
+// src/retrieval/scope.ts
+function normalizeVirtualPath(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/\/+/g, "/").trim();
+  if (normalized.length === 0 || normalized === "/")
+    return "/";
+  const withLeadingSlash = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/g, "") : withLeadingSlash;
+}
+function normalizeVirtualPathScope(scope) {
+  if (scope === undefined)
+    return;
+  const normalized = normalizeVirtualPath(scope);
+  return normalized === "/" ? undefined : normalized;
+}
+function matchesVirtualPathScope(virtualPath, scope) {
+  const normalizedScope = normalizeVirtualPathScope(scope);
+  if (normalizedScope === undefined)
+    return true;
+  return virtualPathScopeToRegExp(normalizedScope).test(normalizeVirtualPath(virtualPath));
+}
+function virtualPathScopeToRegExp(scope) {
+  const normalized = normalizeVirtualPath(scope);
+  const scoped = hasGlob(normalized) || looksLikeFileScope(normalized) ? normalized : `${normalized}/**`;
+  const pattern = scoped.split("/").map((segment, index) => {
+    if (index === 0)
+      return "";
+    if (segment === "**")
+      return "(?:.*)";
+    return escapeRegExp(segment).replace(/\\\*/g, "[^/]*");
+  }).join("/").replace(/\/\(\?:\.\*\)$/u, "(?:/.*)?");
+  return new RegExp(`^${pattern}$`);
+}
+function hasGlob(scope) {
+  return scope.includes("*");
+}
+function looksLikeFileScope(scope) {
+  const finalSegment = scope.split("/").at(-1) ?? "";
+  return /\.[^/.]+$/u.test(finalSegment);
+}
+function escapeRegExp(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/datasource/scope.ts
+function buildDatasourceInstanceSource(skillName, instanceId) {
+  return normalizeVirtualPath(`/${skillName}/${instanceId}`);
+}
+function buildDatasourceChunkSource(skillName, instanceId, chunkId) {
+  return normalizeVirtualPath(`/${skillName}/${instanceId}/${DATASOURCE_CHUNKS_SEGMENT}/${chunkId}`);
+}
+function datasourceSourcePath(skillName, instanceId, chunkId) {
+  return chunkId === undefined ? buildDatasourceInstanceSource(skillName, instanceId) : buildDatasourceChunkSource(skillName, instanceId, chunkId);
+}
+function datasourceSourceHasFragment(source) {
+  return typeof source === "string" && source.includes("#");
+}
+function isDatasourceSource(source) {
+  if (typeof source !== "string" || source.length === 0)
+    return false;
+  if (datasourceSourceHasFragment(source))
+    return false;
+  const normalized = normalizeVirtualPath(source);
+  return normalized !== "/";
+}
+function matchesDatasourceScope(source, scope) {
+  if (datasourceSourceHasFragment(source))
+    return false;
+  return matchesVirtualPathScope(source, scope);
+}
+var DATASOURCE_CHUNKS_SEGMENT = "chunks";
+var init_scope = () => {};
+
+// src/datasource/connector-skill.ts
+class ConnectorDatasourceSkill {
+  definition;
+  connector;
+  instanceId;
+  instances;
+  pollingIntervalMs;
+  tags;
+  store;
+  dedupeWindowMs;
+  lastIndexedAt;
+  lastPolledAt;
+  lastError;
+  seenDocs = new Map;
+  constructor(definition, options) {
+    this.definition = definition;
+    this.connector = options.connector;
+    this.instanceId = options.instanceId ?? DEFAULT_INSTANCE_ID;
+    this.instances = options.instances !== undefined && options.instances.length > 0 ? options.instances : [this.instanceId];
+    this.pollingIntervalMs = options.pollingIntervalMs ?? DEFAULT_POLLING_INTERVAL_MS;
+    this.tags = options.tags ?? definition.defaultTags;
+    this.lastIndexedAt = options.lastIndexedAt;
+    this.dedupeWindowMs = options.dedupeWindowMs ?? 0;
+    this.store = new DatasourceChunkStore({
+      skillName: definition.skillName,
+      instanceId: this.instanceId,
+      workspaceRoot: options.workspaceRoot,
+      maxChunkChars: options.maxChunkChars
+    });
+  }
+  describe() {
+    return {
+      name: this.definition.skillName,
+      id: this.definition.skillName,
+      type: this.definition.skillType,
+      description: this.definition.description,
+      capabilities: this.definition.capabilities,
+      tags: this.tags,
+      status: "active",
+      datasourceId: this.definition.skillName,
+      instanceId: this.instanceId,
+      instances: this.instances
+    };
+  }
+  polling() {
+    return {
+      mode: this.pollingIntervalMs > 0 ? "poll" : "none",
+      ...this.pollingIntervalMs > 0 ? { intervalMs: this.pollingIntervalMs } : {},
+      lastIndexedAt: this.lastIndexedAt,
+      ...this.lastPolledAt !== undefined ? { lastPolledAt: this.lastPolledAt } : {},
+      ...this.lastError !== undefined ? { lastError: this.lastError } : {}
+    };
+  }
+  async index() {
+    this.lastPolledAt = Date.now();
+    let fetched;
+    try {
+      fetched = await this.connector.fetch();
+    } catch {
+      return this.fail("datasource-unavailable", "connector failed unexpectedly");
+    }
+    if (!fetched.ok) {
+      const code = connectorFailureToDiagnosticCode(fetched.reason);
+      const message = boundDiagnosticText(fetched.message ?? fetched.reason);
+      return this.fail(code, `${fetched.reason}: ${message}`);
+    }
+    const documents = this.applyDedupeWindow(fetched.documents);
+    const chunkCount = this.store.replaceDocuments(documents);
+    this.lastIndexedAt = Date.now();
+    this.lastError = undefined;
+    const diagnostics = (fetched.warnings ?? []).map((warning) => ({
+      code: "datasource-index-failed",
+      severity: "warning",
+      message: boundDiagnosticText(warning),
+      instanceId: this.instanceId,
+      source: this.definition.skillName
+    }));
+    if (chunkCount === 0) {
+      diagnostics.push({
+        code: "datasource-empty",
+        severity: "info",
+        message: "datasource fetch returned no indexable documents",
+        instanceId: this.instanceId,
+        source: this.definition.skillName
+      });
+    }
+    return {
+      ok: true,
+      instanceId: this.instanceId,
+      skill: this.definition.skillName,
+      chunkCount,
+      indexedAt: this.lastIndexedAt,
+      diagnostics
+    };
+  }
+  retrievalMethods() {
+    return [
+      new ConnectorLexicalMethod({
+        skillName: this.definition.skillName,
+        skillType: this.definition.skillType,
+        instanceId: this.instanceId,
+        tags: this.tags,
+        store: this.store
+      })
+    ];
+  }
+  describeSources() {
+    const out = this.instances.map((instanceId) => ({
+      source: datasourceSourcePath(this.definition.skillName, instanceId),
+      datasourceId: this.definition.skillName,
+      skill: this.definition.skillName,
+      instanceId,
+      contentType: this.definition.contentType,
+      metadata: {
+        datasourceId: this.definition.skillName,
+        instanceId,
+        tags: this.tags
+      }
+    }));
+    for (const hierarchy of this.store.hierarchies()) {
+      if (hierarchy.length === 0)
+        continue;
+      out.push({
+        source: `${datasourceSourcePath(this.definition.skillName, this.instanceId)}/${hierarchy.join("/")}`,
+        datasourceId: this.definition.skillName,
+        skill: this.definition.skillName,
+        instanceId: this.instanceId,
+        contentType: this.definition.contentType,
+        metadata: {
+          datasourceId: this.definition.skillName,
+          instanceId: this.instanceId,
+          hierarchy
+        }
+      });
+    }
+    return out;
+  }
+  skillManifest() {
+    const skillName = this.definition.skillName;
+    const instanceScopes = this.instances.map((instanceId) => `- \`${datasourceSourcePath(skillName, instanceId)}\``).join(`
+`);
+    const cadence = this.pollingIntervalMs > 0 ? `roughly every ${Math.round(this.pollingIntervalMs / 60000)} minute(s) when auto-refresh runs` : "on manual refresh only";
+    return {
+      name: `datasource-${skillName}`,
+      description: this.definition.manifestDescription,
+      content: [
+        `# ${this.definition.description} (${this.definition.skillType})`,
+        "",
+        "## When to use",
+        this.definition.manifestDescription,
+        "",
+        "## Indexing",
+        `Indexing is server-managed and refreshed ${cadence}. You do not trigger indexing; just search.`,
+        "",
+        "## How to search",
+        "Call `search_datasource_documents` with a natural-language `query`. Optionally pass `topK` and a narrowing `scope`. Available authorized scopes:",
+        instanceScopes.length > 0 ? instanceScopes : "- (no authorized instances)",
+        "",
+        "`scope` can only narrow within already-authorized scopes; it can never widen access.",
+        "",
+        "## Output rules",
+        `Datasource source identifiers such as \`/${skillName}/<instance>/chunks/<id>\` are stable and traceable. Result metadata may carry real file paths or account identifiers; you may cite them in the visible answer when they help the user locate the underlying item. Privacy is the operator's responsibility: run AutoRAG with a local LLM if results must not leave this machine.`,
+        ...this.definition.manifestNotes !== undefined && this.definition.manifestNotes.length > 0 ? ["", ...this.definition.manifestNotes] : []
+      ].join(`
+`)
+    };
+  }
+  applyDedupeWindow(documents) {
+    if (this.dedupeWindowMs <= 0)
+      return documents;
+    const now = Date.now();
+    for (const [docId, seenAt] of this.seenDocs) {
+      if (now - seenAt > this.dedupeWindowMs)
+        this.seenDocs.delete(docId);
+    }
+    const out = [];
+    const inBatch = new Set;
+    for (const document of documents) {
+      if (inBatch.has(document.docId))
+        continue;
+      inBatch.add(document.docId);
+      this.seenDocs.set(document.docId, now);
+      out.push(document);
+    }
+    return out;
+  }
+  fail(code, message) {
+    const sanitized = boundDiagnosticText(message);
+    this.lastError = sanitized;
+    const diagnostic = {
+      code,
+      severity: code === "datasource-unavailable" || code === "datasource-empty" ? "warning" : "error",
+      message: sanitized,
+      instanceId: this.instanceId,
+      source: this.definition.skillName
+    };
+    return {
+      ok: false,
+      instanceId: this.instanceId,
+      skill: this.definition.skillName,
+      indexedAt: Date.now(),
+      diagnostics: [diagnostic],
+      error: sanitized,
+      code,
+      message: sanitized
+    };
+  }
+}
+
+class ConnectorLexicalMethod {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  describe() {
+    const { skillName, skillType, tags } = this.options;
+    return {
+      name: `${skillName}-lexical`,
+      type: "bm25",
+      description: `Lexical retrieval over indexed ${skillType} chunks`,
+      status: "active",
+      capabilities: ["lexical", "scoped", "path-opaque-sources"],
+      datasourceId: skillName,
+      tags: [...tags]
+    };
+  }
+  async retrieve(query, options) {
+    const trimmed = query.trim();
+    if (trimmed.length === 0)
+      return [];
+    const topK = options.topK ?? DEFAULT_TOP_K;
+    let hits;
+    try {
+      hits = this.options.store.search(trimmed, Math.max(topK * 3, topK));
+    } catch {
+      return [];
+    }
+    const { skillName, instanceId } = this.options;
+    const mapped = [];
+    for (const { chunk, score } of hits) {
+      const source = datasourceSourcePath(skillName, instanceId, chunk.chunkId);
+      if (!this.matchesScope(source, options.scope, options.allowedScopes))
+        continue;
+      mapped.push({
+        id: `${skillName}:${instanceId}:${chunk.chunkId}`,
+        content: chunk.content,
+        source,
+        score,
+        metadata: {
+          ...chunk.metadata,
+          method: `${skillName}-lexical`,
+          datasourceId: skillName,
+          instanceId,
+          chunkId: chunk.chunkId,
+          ...chunk.title !== undefined ? { title: chunk.title } : {},
+          ...chunk.hierarchy.length > 0 ? { hierarchy: chunk.hierarchy.join("/") } : {},
+          ...chunk.publishedAt !== undefined ? { publishedAt: chunk.publishedAt } : {}
+        }
+      });
+      if (mapped.length >= topK)
+        break;
+    }
+    return mapped;
+  }
+  matchesScope(source, scope, allowedScopes) {
+    if (!matchesDatasourceScope(source, scope))
+      return false;
+    if (allowedScopes === undefined || allowedScopes.length === 0)
+      return true;
+    return allowedScopes.some((entry) => matchesDatasourceScope(source, entry));
+  }
+}
+var DEFAULT_POLLING_INTERVAL_MS, DEFAULT_INSTANCE_ID = "default", DEFAULT_TOP_K = 20;
+var init_connector_skill = __esm(() => {
+  init_chunk_store();
+  init_connector2();
+  init_scope();
+  DEFAULT_POLLING_INTERVAL_MS = 15 * 60 * 1000;
+});
+
+// src/datasource/skills/discord/skill.ts
+var DISCORD_SKILL_DEFINITION, DiscordSkill;
+var init_skill = __esm(() => {
+  init_connector_skill();
+  init_connector();
+  DISCORD_SKILL_DEFINITION = {
+    skillName: "discord",
+    skillType: "discord-guild",
+    description: "Discord guild datasource",
+    capabilities: ["chat", "api", "polling"],
+    defaultTags: ["discord", "chat", "pii"],
+    contentType: "chat",
+    manifestDescription: "Search indexed Discord messages across authorized guild channels and threads. Use for questions about Discord conversations or community discussions.",
+    manifestNotes: ["Channel visibility and history windows are bounded by the server-configured bot permissions."]
+  };
+  DiscordSkill = class DiscordSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(DISCORD_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new DiscordConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/discord/index.ts
+var init_discord = __esm(() => {
+  init_connector();
+  init_skill();
+});
+
+// src/datasource/skills/gdrive/connector.ts
+class GDriveConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV2);
+    if (token === undefined)
+      return { ok: false, reason: "not-configured", message: "auth token not configured" };
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL2;
+    const request = {
+      headers: { Authorization: `Bearer ${token}` },
+      timeoutMs: this.options.timeoutMs,
+      fetchImpl: this.options.fetchImpl,
+      signal
+    };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES2;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS2;
+    const files = [];
+    let pageToken;
+    for (let page = 0;page < maxPages; page += 1) {
+      const url = new URL(`${baseUrl}/files`);
+      url.searchParams.set("pageSize", "100");
+      url.searchParams.set("fields", "nextPageToken,files(id,name,mimeType,modifiedTime,parents)");
+      const query = this.options.folderId !== undefined ? `trashed=false and '${this.options.folderId}' in parents` : "trashed=false";
+      url.searchParams.set("q", query);
+      if (this.options.includeSharedDrives === true) {
+        url.searchParams.set("supportsAllDrives", "true");
+        url.searchParams.set("includeItemsFromAllDrives", "true");
+        url.searchParams.set("corpora", "allDrives");
+      }
+      if (pageToken !== undefined)
+        url.searchParams.set("pageToken", pageToken);
+      const result = await httpJson(url.toString(), request);
+      if (!result.ok)
+        return { ok: false, reason: result.reason, message: `file list failed: ${result.message}` };
+      const envelope = asRecord(result.json);
+      if (envelope === undefined)
+        return { ok: false, reason: "invalid-data", message: "file list malformed" };
+      for (const raw of asArray(envelope.files)) {
+        const file = asRecord(raw);
+        const id = asString(file?.id);
+        const name = asString(file?.name);
+        const mimeType = asString(file?.mimeType);
+        if (id === undefined || name === undefined || mimeType === undefined)
+          continue;
+        files.push({ id, name, mimeType, modifiedTime: asString(file?.modifiedTime) });
+      }
+      pageToken = asString(envelope.nextPageToken);
+      if (pageToken === undefined || pageToken.length === 0)
+        break;
+    }
+    const documents = [];
+    const warnings = [];
+    for (const file of files) {
+      if (documents.length >= maxDocuments)
+        break;
+      const exportMime = EXPORT_MIME[file.mimeType];
+      let contentUrl;
+      if (exportMime !== undefined) {
+        contentUrl = `${baseUrl}/files/${file.id}/export?mimeType=${encodeURIComponent(exportMime)}`;
+      } else if (DOWNLOAD_MIME.has(file.mimeType)) {
+        contentUrl = `${baseUrl}/files/${file.id}?alt=media`;
+      } else {
+        continue;
+      }
+      const contentResult = await httpText(contentUrl, request);
+      if (!contentResult.ok) {
+        warnings.push(`file export failed: ${contentResult.message}`);
+        continue;
+      }
+      const content = contentResult.text.trim().slice(0, MAX_CONTENT_CHARS);
+      if (content.length === 0)
+        continue;
+      documents.push({
+        docId: file.id,
+        hierarchy: ["files"],
+        title: file.name,
+        content,
+        publishedAt: parseEpochMs(file.modifiedTime),
+        metadata: {
+          mimeType: file.mimeType,
+          ...file.modifiedTime !== undefined ? { modifiedTime: file.modifiedTime } : {}
+        }
+      });
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+var DEFAULT_BASE_URL2 = "https://www.googleapis.com/drive/v3", DEFAULT_TOKEN_ENV2 = "GDRIVE_ACCESS_TOKEN", DEFAULT_MAX_PAGES2 = 10, DEFAULT_MAX_DOCUMENTS2 = 500, MAX_CONTENT_CHARS = 1e5, EXPORT_MIME, DOWNLOAD_MIME;
+var init_connector3 = __esm(() => {
+  EXPORT_MIME = {
+    "application/vnd.google-apps.document": "text/plain",
+    "application/vnd.google-apps.spreadsheet": "text/csv"
+  };
+  DOWNLOAD_MIME = new Set(["text/plain", "text/markdown", "text/csv", "application/json"]);
+});
+
+// src/datasource/skills/gdrive/rclone-connector.ts
+import { spawn } from "node:child_process";
+
+class RcloneConnector {
+  options;
+  runner;
+  constructor(options = {}) {
+    this.options = options;
+    this.runner = options.runner ?? ((args, timeoutMs) => runBinary(options.binaryPath ?? DEFAULT_BINARY, args, timeoutMs));
+  }
+  async fetch() {
+    const remote = this.options.remote;
+    if (remote === undefined || remote.length === 0) {
+      return { ok: false, reason: "not-configured", message: "rclone remote not configured" };
+    }
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+    const exportFormats = this.options.exportFormats ?? DEFAULT_EXPORT_FORMATS;
+    const extensions = this.options.extensions ?? DEFAULT_EXTENSIONS;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS3;
+    const maxBytes = this.options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE;
+    let listResult;
+    try {
+      listResult = await this.runner(["lsjson", remote, "--recursive", "--files-only", "--drive-export-formats", exportFormats], timeoutMs);
+    } catch {
+      return { ok: false, reason: "unavailable", message: "rclone binary not found or failed to spawn" };
+    }
+    if (!listResult.ok) {
+      return { ok: false, reason: classifyFailure(listResult.stderr), message: shortFailure(listResult) };
+    }
+    let entries;
+    try {
+      entries = asArray(JSON.parse(listResult.stdout));
+    } catch {
+      return { ok: false, reason: "invalid-data", message: "rclone listing was not valid JSON" };
+    }
+    const documents = [];
+    let readFailures = 0;
+    let skipped = 0;
+    for (const raw of entries) {
+      if (documents.length >= maxDocuments)
+        break;
+      const entry = asRecord(raw);
+      const path = asString(entry?.Path);
+      const name = asString(entry?.Name);
+      if (entry === undefined || path === undefined || name === undefined)
+        continue;
+      const extension = name.includes(".") ? name.slice(name.lastIndexOf(".")).toLowerCase() : "";
+      if (!extensions.includes(extension)) {
+        skipped += 1;
+        continue;
+      }
+      const size = typeof entry.Size === "number" ? entry.Size : 0;
+      if (size > maxBytes) {
+        skipped += 1;
+        continue;
+      }
+      const target = remote.endsWith(":") || remote.endsWith("/") ? `${remote}${path}` : `${remote}/${path}`;
+      let content = "";
+      try {
+        const catResult = await this.runner(["cat", target, "--drive-export-formats", exportFormats, "--count", String(maxBytes)], timeoutMs);
+        if (!catResult.ok) {
+          readFailures += 1;
+          continue;
+        }
+        content = catResult.stdout.trim().slice(0, MAX_CONTENT_CHARS2);
+      } catch {
+        readFailures += 1;
+        continue;
+      }
+      if (content.length === 0)
+        continue;
+      const segments = path.split("/");
+      documents.push({
+        docId: path,
+        hierarchy: ["files", ...segments.slice(0, -1)],
+        title: name,
+        content,
+        publishedAt: parseEpochMs(asString(entry.ModTime)),
+        metadata: {
+          ...asString(entry.MimeType) !== undefined ? { mimeType: asString(entry.MimeType) } : {},
+          size
+        }
+      });
+    }
+    const warnings = [];
+    if (readFailures > 0)
+      warnings.push(`${readFailures} file(s) failed to read`);
+    if (skipped > 0)
+      warnings.push(`${skipped} file(s) skipped (non-text or oversized)`);
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+function classifyFailure(stderr) {
+  const lower = stderr.toLowerCase();
+  if (lower.includes("didn't find section") || lower.includes("config file") || lower.includes("no remotes")) {
+    return "not-configured";
+  }
+  if (lower.includes("oauth") || lower.includes("token") || lower.includes("unauthorized") || lower.includes("401")) {
+    return "auth";
+  }
+  if (lower.includes("permission") || lower.includes("403") || lower.includes("forbidden"))
+    return "permission";
+  return "api-error";
+}
+function shortFailure(result) {
+  return `rclone exited with code ${result.code ?? "unknown"}`;
+}
+function runBinary(binary, args, timeoutMs) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(binary, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolvePromise({ ok: false, stdout, stderr, code: null });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolvePromise({ ok: code === 0, stdout, stderr, code });
+    });
+  });
+}
+var DEFAULT_BINARY = "rclone", DEFAULT_EXTENSIONS, DEFAULT_EXPORT_FORMATS = "txt,csv", DEFAULT_MAX_DOCUMENTS3 = 200, DEFAULT_MAX_BYTES_PER_FILE, DEFAULT_TIMEOUT_MS2 = 60000, MAX_CONTENT_CHARS2 = 1e5;
+var init_rclone_connector = __esm(() => {
+  DEFAULT_EXTENSIONS = [".txt", ".md", ".csv", ".json", ".html", ".rst", ".org"];
+  DEFAULT_MAX_BYTES_PER_FILE = 2 * 1024 * 1024;
+});
+
+// src/datasource/skills/gdrive/skill.ts
+var GDRIVE_SKILL_DEFINITION, GDriveSkill;
+var init_skill2 = __esm(() => {
+  init_connector_skill();
+  init_connector3();
+  GDRIVE_SKILL_DEFINITION = {
+    skillName: "gdrive",
+    skillType: "google-drive",
+    description: "Google Drive datasource",
+    capabilities: ["documents", "api", "polling"],
+    defaultTags: ["gdrive", "documents", "pii"],
+    contentType: "document",
+    manifestDescription: "Search indexed Google Drive documents (Docs, Sheets, plain text). Use for questions about files stored in the authorized Drive account or folder.",
+    manifestNotes: [
+      "Shared-drive permissions are enforced by the server-configured OAuth token; unexported binary formats are not indexed."
+    ]
+  };
+  GDriveSkill = class GDriveSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(GDRIVE_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new GDriveConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/gdrive/index.ts
+var init_gdrive = __esm(() => {
+  init_connector3();
+  init_rclone_connector();
+  init_skill2();
+});
+
+// src/datasource/skills/github/connector.ts
+class GitHubConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const repos = this.options.repos ?? [];
+    if (repos.length === 0)
+      return { ok: false, reason: "not-configured", message: "no repositories configured" };
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV3);
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL3;
+    const request = {
+      headers: {
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "User-Agent": "autorag-datasource",
+        ...token !== undefined ? { Authorization: `Bearer ${token}` } : {}
+      },
+      timeoutMs: this.options.timeoutMs,
+      fetchImpl: this.options.fetchImpl,
+      signal
+    };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES3;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS4;
+    const documents = [];
+    const warnings = [];
+    for (const repo of repos) {
+      if (documents.length >= maxDocuments)
+        break;
+      const [owner, name] = repo.split("/", 2);
+      if (owner === undefined || name === undefined || owner.length === 0 || name.length === 0) {
+        warnings.push(`repository entry ${repos.indexOf(repo) + 1} is not owner/repo`);
+        continue;
+      }
+      for (let page = 1;page <= maxPages && documents.length < maxDocuments; page += 1) {
+        const url = `${baseUrl}/repos/${owner}/${name}/issues?state=all&per_page=100&page=${page}`;
+        const result = await httpJson(url, request);
+        if (!result.ok) {
+          if (result.reason === "auth")
+            return { ok: false, reason: "auth", message: "github: unauthorized" };
+          if (result.reason === "rate-limited" || result.reason === "permission") {
+            return { ok: false, reason: "rate-limited", message: "github: rate limited or forbidden" };
+          }
+          warnings.push(`repo ${owner}-${name} fetch failed: ${result.message}`);
+          break;
+        }
+        const items = asArray(result.json);
+        if (items.length === 0)
+          break;
+        for (const raw of items) {
+          if (documents.length >= maxDocuments)
+            break;
+          const item = asRecord(raw);
+          const number = asNumber(item?.number);
+          const title = asString(item?.title);
+          if (item === undefined || number === undefined || title === undefined)
+            continue;
+          const isPull = asRecord(item.pull_request) !== undefined;
+          const body = asString(item.body) ?? "";
+          const labels = asArray(item.labels).map((label) => asString(asRecord(label)?.name)).filter((label) => label !== undefined);
+          documents.push({
+            docId: `${owner}-${name}-${number}`,
+            hierarchy: [owner, name, isPull ? "pulls" : "issues"],
+            title: `#${number} ${title}`,
+            content: body.length > 0 ? `${title}
+
+${body}` : title,
+            publishedAt: parseEpochMs(item.updated_at),
+            metadata: {
+              state: asString(item.state) ?? "unknown",
+              number,
+              kind: isPull ? "pull" : "issue",
+              labels
+            }
+          });
+        }
+        if (items.length < 100)
+          break;
+      }
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+var DEFAULT_BASE_URL3 = "https://api.github.com", DEFAULT_TOKEN_ENV3 = "GITHUB_TOKEN", DEFAULT_MAX_PAGES3 = 10, DEFAULT_MAX_DOCUMENTS4 = 500;
+var init_connector4 = () => {};
+
+// src/datasource/skills/github/skill.ts
+var GITHUB_SKILL_DEFINITION, GitHubSkill;
+var init_skill3 = __esm(() => {
+  init_connector_skill();
+  init_connector4();
+  GITHUB_SKILL_DEFINITION = {
+    skillName: "github",
+    skillType: "github-issues",
+    description: "GitHub Issues/PRs datasource",
+    capabilities: ["issues", "api", "polling"],
+    defaultTags: ["github", "issues"],
+    contentType: "issue",
+    manifestDescription: "Search indexed GitHub issues and pull requests for the configured repositories. Use for questions about bug reports, feature requests, and review discussions.",
+    manifestNotes: ["Repository visibility is bounded by the server-configured token scopes."]
+  };
+  GitHubSkill = class GitHubSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(GITHUB_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new GitHubConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/github/index.ts
+var init_github = __esm(() => {
+  init_connector4();
+  init_skill3();
+});
+
+// src/datasource/skills/gmail/himalaya-connector.ts
+import { spawn as spawn2 } from "node:child_process";
+
+class HimalayaConnector {
+  options;
+  runner;
+  constructor(options = {}) {
+    this.options = options;
+    this.runner = options.runner ?? ((args, timeoutMs) => runBinary2(options.binaryPath ?? DEFAULT_BINARY2, args, timeoutMs));
+  }
+  async fetch() {
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS5;
+    const accountArgs = this.options.account !== undefined ? ["--account", this.options.account] : [];
+    const folderArgs = this.options.folder !== undefined ? ["--folder", this.options.folder] : [];
+    const listArgs = [
+      "envelope",
+      "list",
+      ...accountArgs,
+      ...folderArgs,
+      "--page-size",
+      String(this.options.pageSize ?? DEFAULT_PAGE_SIZE),
+      "--output",
+      "json"
+    ];
+    let listResult;
+    try {
+      listResult = await this.runner(listArgs, timeoutMs);
+    } catch {
+      return { ok: false, reason: "unavailable", message: "himalaya binary not found or failed to spawn" };
+    }
+    if (!listResult.ok) {
+      return { ok: false, reason: classifyFailure2(listResult.stderr), message: shortFailure2(listResult) };
+    }
+    let envelopes;
+    try {
+      envelopes = asArray(JSON.parse(listResult.stdout));
+    } catch {
+      return { ok: false, reason: "invalid-data", message: "envelope listing was not valid JSON" };
+    }
+    const account = this.options.account ?? "default";
+    const folder = this.options.folder ?? "INBOX";
+    const documents = [];
+    let readFailures = 0;
+    for (const raw of envelopes.slice(0, maxDocuments)) {
+      const envelope = asRecord(raw);
+      const id = asString(envelope?.id);
+      if (envelope === undefined || id === undefined)
+        continue;
+      const subject = asString(envelope.subject) ?? "(no subject)";
+      const from = asRecord(envelope.from);
+      const fromText = [asString(from?.name), asString(from?.addr)].filter(Boolean).join(" ").trim();
+      let body = "";
+      try {
+        const readResult = await this.runner(["message", "read", ...accountArgs, ...folderArgs, id], timeoutMs);
+        if (readResult.ok)
+          body = readResult.stdout.trim().slice(0, MAX_BODY_CHARS);
+        else
+          readFailures += 1;
+      } catch {
+        readFailures += 1;
+      }
+      const headerBlock = [
+        `Subject: ${subject}`,
+        ...fromText.length > 0 ? [`From: ${fromText}`] : [],
+        ...asString(envelope.date) !== undefined ? [`Date: ${asString(envelope.date)}`] : []
+      ].join(`
+`);
+      documents.push({
+        docId: `${account}-${folder}-${id}`,
+        hierarchy: ["accounts", account, folder],
+        title: subject,
+        content: body.length > 0 ? `${headerBlock}
+
+${body}` : headerBlock,
+        publishedAt: parseHimalayaDate(asString(envelope.date)),
+        metadata: {
+          account,
+          folder,
+          messageId: id,
+          ...asArray(envelope.flags).length > 0 ? {
+            flags: asArray(envelope.flags).map((flag) => asString(flag)).filter(Boolean)
+          } : {}
+        }
+      });
+    }
+    const warnings = readFailures > 0 ? [`${readFailures} message(s) failed to read`] : undefined;
+    return { ok: true, documents, ...warnings !== undefined ? { warnings } : {} };
+  }
+}
+function parseHimalayaDate(value) {
+  if (value === undefined || value.length === 0)
+    return;
+  const parsed = Date.parse(value.replace(" ", "T"));
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
+function classifyFailure2(stderr) {
+  const lower = stderr.toLowerCase();
+  if (lower.includes("cannot find") && lower.includes("account"))
+    return "not-configured";
+  if (lower.includes("auth") || lower.includes("login") || lower.includes("credential"))
+    return "auth";
+  return "api-error";
+}
+function shortFailure2(result) {
+  return `himalaya exited with code ${result.code ?? "unknown"}`;
+}
+function runBinary2(binary, args, timeoutMs) {
+  return new Promise((resolvePromise) => {
+    const child = spawn2(binary, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolvePromise({ ok: false, stdout, stderr, code: null });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolvePromise({ ok: code === 0, stdout, stderr, code });
+    });
+  });
+}
+var DEFAULT_BINARY2 = "himalaya", DEFAULT_PAGE_SIZE = 100, DEFAULT_MAX_DOCUMENTS5 = 50, DEFAULT_TIMEOUT_MS3 = 30000, MAX_BODY_CHARS = 50000;
+var init_himalaya_connector = () => {};
+
+// src/datasource/skills/gmail/connector.ts
+class GmailConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV4);
+    if (token === undefined)
+      return { ok: false, reason: "not-configured", message: "auth token not configured" };
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL4;
+    const request = {
+      headers: { Authorization: `Bearer ${token}` },
+      timeoutMs: this.options.timeoutMs,
+      fetchImpl: this.options.fetchImpl,
+      signal
+    };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES4;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS6;
+    const messageIds = [];
+    let pageToken;
+    for (let page = 0;page < maxPages && messageIds.length < maxDocuments; page += 1) {
+      const url = new URL(`${baseUrl}/users/me/messages`);
+      url.searchParams.set("maxResults", "100");
+      for (const labelId of this.options.labelIds ?? [])
+        url.searchParams.append("labelIds", labelId);
+      if (this.options.query !== undefined)
+        url.searchParams.set("q", this.options.query);
+      if (pageToken !== undefined)
+        url.searchParams.set("pageToken", pageToken);
+      const result = await httpJson(url.toString(), request);
+      if (!result.ok)
+        return { ok: false, reason: result.reason, message: `message list failed: ${result.message}` };
+      const envelope = asRecord(result.json);
+      if (envelope === undefined)
+        return { ok: false, reason: "invalid-data", message: "message list malformed" };
+      for (const raw of asArray(envelope.messages)) {
+        const id = asString(asRecord(raw)?.id);
+        if (id !== undefined)
+          messageIds.push(id);
+      }
+      pageToken = asString(envelope.nextPageToken);
+      if (pageToken === undefined || pageToken.length === 0)
+        break;
+    }
+    const documents = [];
+    let failedFetches = 0;
+    for (const id of messageIds.slice(0, maxDocuments)) {
+      const result = await httpJson(`${baseUrl}/users/me/messages/${id}?format=full`, request);
+      if (!result.ok) {
+        if (result.reason === "auth")
+          return { ok: false, reason: "auth", message: "gmail: unauthorized" };
+        if (result.reason === "rate-limited") {
+          return { ok: false, reason: "rate-limited", message: "gmail: rate limited" };
+        }
+        failedFetches += 1;
+        continue;
+      }
+      const message = asRecord(result.json);
+      if (message === undefined) {
+        failedFetches += 1;
+        continue;
+      }
+      const payload = asRecord(message.payload);
+      const headers = headerMap(payload);
+      const subject = headers.get("subject") ?? "(no subject)";
+      const body = (extractBody(payload) ?? asString(message.snippet) ?? "").slice(0, MAX_BODY_CHARS2);
+      const labelIds = asArray(message.labelIds).map((label) => asString(label)).filter((label) => label !== undefined);
+      const internalDate = asString(message.internalDate);
+      const publishedAt = internalDate !== undefined && /^\d+$/u.test(internalDate) ? Number(internalDate) : undefined;
+      const headerBlock = [
+        `Subject: ${subject}`,
+        ...headers.has("from") ? [`From: ${headers.get("from")}`] : [],
+        ...headers.has("to") ? [`To: ${headers.get("to")}`] : [],
+        ...headers.has("date") ? [`Date: ${headers.get("date")}`] : []
+      ].join(`
+`);
+      documents.push({
+        docId: id,
+        hierarchy: ["labels", this.options.labelIds?.[0] ?? "all"],
+        title: subject,
+        content: `${headerBlock}
+
+${body}`.trim(),
+        ...publishedAt !== undefined ? { publishedAt } : {},
+        metadata: {
+          ...asString(message.threadId) !== undefined ? { threadId: asString(message.threadId) } : {},
+          labelIds
+        }
+      });
+    }
+    const warnings = failedFetches > 0 ? [`${failedFetches} message(s) failed to fetch`] : undefined;
+    return { ok: true, documents, ...warnings !== undefined ? { warnings } : {} };
+  }
+}
+function headerMap(payload) {
+  const map = new Map;
+  for (const raw of asArray(payload?.headers)) {
+    const header = asRecord(raw);
+    const name = asString(header?.name)?.toLowerCase();
+    const value = asString(header?.value);
+    if (name !== undefined && value !== undefined && !map.has(name))
+      map.set(name, value);
+  }
+  return map;
+}
+function extractBody(payload) {
+  if (payload === undefined)
+    return;
+  const mimeType = asString(payload.mimeType);
+  const data = asString(asRecord(payload.body)?.data);
+  if (mimeType === "text/plain" && data !== undefined)
+    return decodeBase64Url(data);
+  const collected = [];
+  for (const raw of asArray(payload.parts)) {
+    const part = asRecord(raw);
+    const text = extractBody(part);
+    if (text !== undefined && text.length > 0)
+      collected.push(text);
+  }
+  if (collected.length > 0)
+    return collected.join(`
+`);
+  return data !== undefined ? decodeBase64Url(data) : undefined;
+}
+function decodeBase64Url(data) {
+  try {
+    return Buffer.from(data, "base64url").toString("utf8");
+  } catch {
+    return "";
+  }
+}
+var DEFAULT_BASE_URL4 = "https://gmail.googleapis.com/gmail/v1", DEFAULT_TOKEN_ENV4 = "GMAIL_ACCESS_TOKEN", DEFAULT_MAX_PAGES4 = 10, DEFAULT_MAX_DOCUMENTS6 = 500, MAX_BODY_CHARS2 = 50000;
+var init_connector5 = () => {};
+
+// src/datasource/skills/gmail/skill.ts
+var GMAIL_SKILL_DEFINITION, GmailSkill;
+var init_skill4 = __esm(() => {
+  init_connector_skill();
+  init_connector5();
+  GMAIL_SKILL_DEFINITION = {
+    skillName: "gmail",
+    skillType: "gmail-account",
+    description: "Gmail datasource",
+    capabilities: ["email", "api", "polling"],
+    defaultTags: ["gmail", "email", "pii"],
+    contentType: "email",
+    manifestDescription: "Search indexed Gmail messages from the authorized account and labels. Use for questions about email conversations, decisions, or attachments discussed over email.",
+    manifestNotes: ["Label and folder visibility is bounded by the server-configured OAuth token."]
+  };
+  GmailSkill = class GmailSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(GMAIL_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new GmailConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/gmail/index.ts
+var init_gmail = __esm(() => {
+  init_connector5();
+  init_himalaya_connector();
+  init_skill4();
+});
+
+// src/datasource/skills/mail-export/connector.ts
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, dirname as dirname2, extname, join as join3 } from "node:path";
+import { simpleParser } from "mailparser";
+
+class MailExportConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch() {
+    const paths = this.options.paths ?? [];
+    if (paths.length === 0)
+      return { ok: false, reason: "not-configured", message: "no mail export paths configured" };
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS7;
+    const maxBytes = this.options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE2;
+    const files = [];
+    let missingPaths = 0;
+    for (const path of paths) {
+      try {
+        const info = await stat(path);
+        if (info.isDirectory()) {
+          const entries = await readdir(path, { recursive: true, withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isFile())
+              continue;
+            const extension = extname(entry.name).toLowerCase();
+            if (extension === ".eml" || extension === ".mbox") {
+              files.push(join3(entry.parentPath, entry.name));
+            }
+          }
+        } else if (info.isFile()) {
+          files.push(path);
+        }
+      } catch {
+        missingPaths += 1;
+      }
+    }
+    if (missingPaths === paths.length) {
+      return { ok: false, reason: "unavailable", message: "no configured mail export paths were readable" };
+    }
+    const documents = [];
+    const warnings = [];
+    if (missingPaths > 0)
+      warnings.push(`${missingPaths} configured path(s) were unreadable`);
+    let parseFailures = 0;
+    let skippedLarge = 0;
+    for (const file of files.sort()) {
+      if (documents.length >= maxDocuments)
+        break;
+      let bytes;
+      try {
+        const info = await stat(file);
+        if (info.size > maxBytes) {
+          skippedLarge += 1;
+          continue;
+        }
+        bytes = await readFile(file);
+      } catch {
+        parseFailures += 1;
+        continue;
+      }
+      const stem = basename(file, extname(file));
+      const mailboxDir = basename(dirname2(file));
+      const hierarchy = ["mailboxes", mailboxDir, stem];
+      const extension = extname(file).toLowerCase();
+      const rawMessages = extension === ".mbox" ? splitMbox(bytes.toString("utf8")) : [bytes.toString("utf8")];
+      for (const [index, raw] of rawMessages.entries()) {
+        if (documents.length >= maxDocuments)
+          break;
+        try {
+          const parsed = await simpleParser(raw);
+          const subject = parsed.subject ?? "(no subject)";
+          const from = Array.isArray(parsed.from) ? parsed.from[0]?.text : parsed.from?.text;
+          const to = Array.isArray(parsed.to) ? parsed.to[0]?.text : parsed.to?.text;
+          const body = (parsed.text ?? "").trim().slice(0, MAX_BODY_CHARS3);
+          const headerBlock = [
+            `Subject: ${subject}`,
+            ...from !== undefined ? [`From: ${from}`] : [],
+            ...to !== undefined ? [`To: ${to}`] : [],
+            ...parsed.date !== undefined ? [`Date: ${parsed.date.toISOString()}`] : []
+          ].join(`
+`);
+          const content = `${headerBlock}
+
+${body}`.trim();
+          if (content.length === 0)
+            continue;
+          documents.push({
+            docId: extension === ".mbox" ? `${stem}-${index + 1}` : stem,
+            hierarchy,
+            title: subject,
+            content,
+            ...parsed.date !== undefined ? { publishedAt: parsed.date.getTime() } : {},
+            metadata: {
+              path: file,
+              subject,
+              ...from !== undefined ? { from } : {},
+              messageIndex: index
+            }
+          });
+        } catch {
+          parseFailures += 1;
+        }
+      }
+    }
+    if (skippedLarge > 0)
+      warnings.push(`${skippedLarge} file(s) exceeded the size limit and were skipped`);
+    if (parseFailures > 0)
+      warnings.push(`${parseFailures} message(s) failed to parse`);
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+function splitMbox(text) {
+  const lines = text.split(/\r?\n/u);
+  const messages = [];
+  let current = [];
+  for (const line of lines) {
+    if (MBOX_SEPARATOR.test(line) && line.startsWith("From ")) {
+      if (current.length > 0)
+        messages.push(current.join(`
+`));
+      current = [];
+      continue;
+    }
+    current.push(line);
+  }
+  if (current.length > 0)
+    messages.push(current.join(`
+`));
+  return messages.filter((message) => message.trim().length > 0);
+}
+var DEFAULT_MAX_DOCUMENTS7 = 500, DEFAULT_MAX_BYTES_PER_FILE2, MAX_BODY_CHARS3 = 50000, MBOX_SEPARATOR;
+var init_connector6 = __esm(() => {
+  DEFAULT_MAX_BYTES_PER_FILE2 = 50 * 1024 * 1024;
+  MBOX_SEPARATOR = /^From .*\d{4}$/mu;
+});
+
+// src/datasource/skills/mail-export/skill.ts
+var MAIL_EXPORT_SKILL_DEFINITION, MailExportSkill;
+var init_skill5 = __esm(() => {
+  init_connector_skill();
+  init_connector6();
+  MAIL_EXPORT_SKILL_DEFINITION = {
+    skillName: "mail-export",
+    skillType: "mail-export",
+    description: "Local mail export datasource",
+    capabilities: ["email", "filesystem"],
+    defaultTags: ["mail-export", "email", "pii"],
+    contentType: "email",
+    manifestDescription: "Search indexed local mail exports (mbox/eml archives). Use for questions about archived email conversations.",
+    manifestNotes: [
+      "Only the server-configured export paths are indexed; archives are read locally and never uploaded."
+    ]
+  };
+  MailExportSkill = class MailExportSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(MAIL_EXPORT_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new MailExportConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/mail-export/index.ts
+var init_mail_export = __esm(() => {
+  init_connector6();
+  init_skill5();
+});
+
+// src/datasource/skills/notion/connector.ts
+class NotionConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV5);
+    if (token === undefined)
+      return { ok: false, reason: "not-configured", message: "auth token not configured" };
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL5;
+    const request = {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Notion-Version": NOTION_VERSION,
+        "Content-Type": "application/json"
+      },
+      timeoutMs: this.options.timeoutMs,
+      fetchImpl: this.options.fetchImpl,
+      signal
+    };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES5;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS8;
+    const entries = [];
+    let cursor;
+    for (let page = 0;page < maxPages; page += 1) {
+      const body = JSON.stringify({ page_size: 100, ...cursor !== undefined ? { start_cursor: cursor } : {} });
+      const result = await httpJson(`${baseUrl}/search`, { ...request, method: "POST", body });
+      if (!result.ok)
+        return { ok: false, reason: result.reason, message: `search failed: ${result.message}` };
+      const envelope = asRecord(result.json);
+      if (envelope === undefined)
+        return { ok: false, reason: "invalid-data", message: "search response malformed" };
+      for (const raw of asArray(envelope.results)) {
+        const entry = asRecord(raw);
+        if (entry !== undefined)
+          entries.push(entry);
+      }
+      cursor = envelope.has_more === true ? asString(envelope.next_cursor) : undefined;
+      if (cursor === undefined)
+        break;
+    }
+    const documents = [];
+    const warnings = [];
+    for (const entry of entries) {
+      if (documents.length >= maxDocuments)
+        break;
+      const id = asString(entry.id);
+      if (id === undefined)
+        continue;
+      const objectType = asString(entry.object) ?? "page";
+      const title = extractTitle(entry);
+      let blockText = "";
+      if (objectType === "page") {
+        const blocksResult = await httpJson(`${baseUrl}/blocks/${id}/children?page_size=100`, request);
+        if (blocksResult.ok) {
+          blockText = extractBlockText(blocksResult.json);
+        } else {
+          warnings.push(`page content fetch failed: ${blocksResult.message}`);
+        }
+      }
+      const content = [title, blockText].filter((part) => part.length > 0).join(`
+
+`);
+      if (content.length === 0)
+        continue;
+      documents.push({
+        docId: id,
+        hierarchy: hierarchyFor(entry, objectType),
+        ...title.length > 0 ? { title } : {},
+        content,
+        publishedAt: parseEpochMs(entry.last_edited_time),
+        metadata: {
+          objectType,
+          ...asString(entry.last_edited_time) !== undefined ? { lastEditedTime: asString(entry.last_edited_time) } : {}
+        }
+      });
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+function hierarchyFor(entry, objectType) {
+  if (objectType === "database")
+    return ["databases", asString(entry.id) ?? "unknown"];
+  const parent = asRecord(entry.parent);
+  const parentType = asString(parent?.type);
+  if (parentType === "database_id") {
+    return ["databases", asString(parent?.database_id) ?? "unknown"];
+  }
+  if (parentType === "page_id") {
+    return ["pages", asString(parent?.page_id) ?? "unknown"];
+  }
+  return ["pages"];
+}
+function extractTitle(entry) {
+  const directTitle = plainText(entry.title);
+  if (directTitle.length > 0)
+    return directTitle;
+  const properties = asRecord(entry.properties);
+  if (properties === undefined)
+    return "";
+  for (const value of Object.values(properties)) {
+    const property = asRecord(value);
+    if (property === undefined || property.type !== "title")
+      continue;
+    const text = plainText(property.title);
+    if (text.length > 0)
+      return text;
+  }
+  return "";
+}
+function extractBlockText(json) {
+  const envelope = asRecord(json);
+  const lines = [];
+  for (const raw of asArray(envelope?.results)) {
+    const block = asRecord(raw);
+    const type = asString(block?.type);
+    if (block === undefined || type === undefined)
+      continue;
+    if (!TEXT_BLOCK_TYPES.includes(type))
+      continue;
+    const payload = asRecord(block[type]);
+    const text = plainText(payload?.rich_text);
+    if (text.length > 0)
+      lines.push(text);
+  }
+  return lines.join(`
+`);
+}
+function plainText(richText) {
+  return asArray(richText).map((raw) => asString(asRecord(raw)?.plain_text) ?? "").filter((text) => text.length > 0).join("").trim();
+}
+var DEFAULT_BASE_URL5 = "https://api.notion.com/v1", DEFAULT_TOKEN_ENV5 = "NOTION_TOKEN", NOTION_VERSION = "2022-06-28", DEFAULT_MAX_PAGES5 = 10, DEFAULT_MAX_DOCUMENTS8 = 500, TEXT_BLOCK_TYPES;
+var init_connector7 = __esm(() => {
+  TEXT_BLOCK_TYPES = [
+    "paragraph",
+    "heading_1",
+    "heading_2",
+    "heading_3",
+    "bulleted_list_item",
+    "numbered_list_item",
+    "to_do",
+    "quote",
+    "callout",
+    "code"
+  ];
+});
+
+// src/datasource/skills/notion/skill.ts
+var NOTION_SKILL_DEFINITION, NotionSkill;
+var init_skill6 = __esm(() => {
+  init_connector_skill();
+  init_connector7();
+  NOTION_SKILL_DEFINITION = {
+    skillName: "notion",
+    skillType: "notion-workspace",
+    description: "Notion workspace datasource",
+    capabilities: ["documents", "api", "polling"],
+    defaultTags: ["notion", "documents"],
+    contentType: "document",
+    manifestDescription: "Search indexed Notion pages and databases shared with the integration. Use for questions about Notion docs, wikis, and database entries.",
+    manifestNotes: ["Only pages shared with the server-configured integration token are indexed."]
+  };
+  NotionSkill = class NotionSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(NOTION_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new NotionConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/notion/index.ts
+var init_notion = __esm(() => {
+  init_connector7();
+  init_skill6();
+});
+
+// src/datasource/skills/obsidian/connector.ts
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { basename as basename2, extname as extname2, join as join4, relative, sep } from "node:path";
+
+class ObsidianConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch() {
+    const vaultPath = this.options.vaultPath;
+    if (vaultPath === undefined || vaultPath.length === 0) {
+      return { ok: false, reason: "not-configured", message: "vault path not configured" };
+    }
+    try {
+      const info = await stat2(vaultPath);
+      if (!info.isDirectory())
+        return { ok: false, reason: "unavailable", message: "vault path is not a directory" };
+    } catch {
+      return { ok: false, reason: "unavailable", message: "vault path is not readable" };
+    }
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS9;
+    const maxBytes = this.options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE3;
+    const files = [];
+    const walk = async (dir) => {
+      let entries;
+      try {
+        entries = await readdir2(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (!SKIPPED_DIRS.has(entry.name))
+            await walk(join4(dir, entry.name));
+        } else if (entry.isFile() && extname2(entry.name).toLowerCase() === ".md") {
+          files.push(join4(dir, entry.name));
+        }
+      }
+    };
+    await walk(vaultPath);
+    const documents = [];
+    let readFailures = 0;
+    let skippedLarge = 0;
+    for (const file of files.sort()) {
+      if (documents.length >= maxDocuments)
+        break;
+      let text;
+      try {
+        const info = await stat2(file);
+        if (info.size > maxBytes) {
+          skippedLarge += 1;
+          continue;
+        }
+        text = await readFile2(file, "utf8");
+        const relativePath = relative(vaultPath, file);
+        const segments = relativePath.split(sep);
+        const directorySegments = segments.slice(0, -1);
+        const stem = basename2(file, ".md");
+        const { body, frontmatterTags } = stripFrontmatter(text);
+        const inlineTags = matchAll(body, INLINE_TAG_PATTERN, 1);
+        const links = [];
+        const embeds = [];
+        for (const match of body.matchAll(WIKI_LINK_PATTERN)) {
+          const target = match[2]?.trim();
+          if (target === undefined || target.length === 0)
+            continue;
+          (match[1] === "!" ? embeds : links).push(target);
+        }
+        const heading = /^#\s+(.+)$/mu.exec(body)?.[1]?.trim();
+        const content = body.trim().slice(0, MAX_CONTENT_CHARS3);
+        if (content.length === 0)
+          continue;
+        documents.push({
+          docId: relativePath.split(sep).join("__").replace(/\.md$/u, ""),
+          hierarchy: ["folders", ...directorySegments],
+          title: heading ?? stem,
+          content,
+          publishedAt: info.mtimeMs,
+          metadata: {
+            path: file,
+            tags: [...new Set([...frontmatterTags, ...inlineTags])],
+            links,
+            embeds,
+            folder: directorySegments.join("/")
+          }
+        });
+      } catch {
+        readFailures += 1;
+      }
+    }
+    const warnings = [];
+    if (skippedLarge > 0)
+      warnings.push(`${skippedLarge} note(s) exceeded the size limit and were skipped`);
+    if (readFailures > 0)
+      warnings.push(`${readFailures} note(s) failed to read`);
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+function stripFrontmatter(text) {
+  if (!text.startsWith("---"))
+    return { body: text, frontmatterTags: [] };
+  const end = text.indexOf(`
+---`, 3);
+  if (end === -1)
+    return { body: text, frontmatterTags: [] };
+  const frontmatter = text.slice(3, end);
+  const body = text.slice(text.indexOf(`
+`, end + 1) + 1);
+  return { body, frontmatterTags: parseFrontmatterTags(frontmatter) };
+}
+function parseFrontmatterTags(frontmatter) {
+  const lines = frontmatter.split(`
+`);
+  const tags = [];
+  for (const [index, line] of lines.entries()) {
+    const match = /^tags:\s*(.*)$/u.exec(line.trim());
+    if (match === null)
+      continue;
+    const inline = match[1]?.trim() ?? "";
+    if (inline.length > 0) {
+      const cleaned = inline.replace(/^\[/u, "").replace(/\]$/u, "");
+      for (const tag of cleaned.split(/[\s,]+/u)) {
+        const trimmed = tag.trim().replace(/^["'#]+|["']+$/gu, "");
+        if (trimmed.length > 0)
+          tags.push(trimmed);
+      }
+      break;
+    }
+    for (let cursor = index + 1;cursor < lines.length; cursor += 1) {
+      const item = /^\s*-\s*(.+)$/u.exec(lines[cursor] ?? "");
+      if (item === null)
+        break;
+      const trimmed = item[1]?.trim().replace(/^["'#]+|["']+$/gu, "") ?? "";
+      if (trimmed.length > 0)
+        tags.push(trimmed);
+    }
+    break;
+  }
+  return tags;
+}
+function matchAll(text, pattern, group) {
+  const out = [];
+  for (const match of text.matchAll(pattern)) {
+    const value = match[group]?.trim();
+    if (value !== undefined && value.length > 0)
+      out.push(value);
+  }
+  return out;
+}
+var DEFAULT_MAX_DOCUMENTS9 = 1000, DEFAULT_MAX_BYTES_PER_FILE3, MAX_CONTENT_CHARS3 = 1e5, SKIPPED_DIRS, INLINE_TAG_PATTERN, WIKI_LINK_PATTERN;
+var init_connector8 = __esm(() => {
+  DEFAULT_MAX_BYTES_PER_FILE3 = 2 * 1024 * 1024;
+  SKIPPED_DIRS = new Set([".obsidian", ".trash", ".git", "node_modules"]);
+  INLINE_TAG_PATTERN = /(?:^|\s)#([A-Za-z0-9_/-]+)/gu;
+  WIKI_LINK_PATTERN = /(!?)\[\[([^\]|]+)(?:\|[^\]]*)?\]\]/gu;
+});
+
+// src/datasource/skills/obsidian/skill.ts
+var OBSIDIAN_SKILL_DEFINITION, ObsidianSkill;
+var init_skill7 = __esm(() => {
+  init_connector_skill();
+  init_connector8();
+  OBSIDIAN_SKILL_DEFINITION = {
+    skillName: "obsidian",
+    skillType: "obsidian-vault",
+    description: "Obsidian vault datasource",
+    capabilities: ["notes", "filesystem"],
+    defaultTags: ["obsidian", "notes"],
+    contentType: "note",
+    manifestDescription: "Search indexed Obsidian vault notes, including tags, wiki links, and embeds. Use for questions about personal notes and knowledge-base content.",
+    manifestNotes: ["Only the server-configured vault is indexed; note metadata includes tags, links, and embeds."]
+  };
+  ObsidianSkill = class ObsidianSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(OBSIDIAN_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new ObsidianConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/obsidian/index.ts
+var init_obsidian = __esm(() => {
+  init_connector8();
+  init_skill7();
+});
+
+// src/datasource/skills/rss/connector.ts
+import { XMLParser } from "fast-xml-parser";
+
+class RssConnector {
+  options;
+  parser = new XMLParser({ ignoreAttributes: false });
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const feeds = this.options.feeds ?? [];
+    if (feeds.length === 0)
+      return { ok: false, reason: "not-configured", message: "no feeds configured" };
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS10;
+    const maxItemsPerFeed = this.options.maxItemsPerFeed ?? DEFAULT_MAX_ITEMS_PER_FEED;
+    const documents = [];
+    const warnings = [];
+    let failedFeeds = 0;
+    for (const [index, feed] of feeds.entries()) {
+      if (documents.length >= maxDocuments)
+        break;
+      const result = await httpText(feed.url, {
+        headers: { Accept: ACCEPT_HEADER },
+        timeoutMs: this.options.timeoutMs ?? DEFAULT_FEED_TIMEOUT_MS,
+        fetchImpl: this.options.fetchImpl,
+        signal
+      });
+      if (!result.ok) {
+        failedFeeds += 1;
+        warnings.push(`feed ${index + 1} failed: ${result.message}`);
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = this.parser.parse(result.text);
+      } catch {
+        failedFeeds += 1;
+        warnings.push(`feed ${index + 1} failed: unparseable XML`);
+        continue;
+      }
+      const normalized = normalizeFeed(parsed);
+      if (normalized === undefined) {
+        failedFeeds += 1;
+        warnings.push(`feed ${index + 1} failed: unrecognized feed shape`);
+        continue;
+      }
+      const feedTitle = normalized.title ?? `feed-${index + 1}`;
+      const hierarchy = feed.category !== undefined ? ["feeds", feed.category, feedTitle] : ["feeds", feedTitle];
+      for (const item of normalized.items.slice(0, maxItemsPerFeed)) {
+        if (documents.length >= maxDocuments)
+          break;
+        const title = item.title ?? "(untitled)";
+        const body = stripHtml(item.body ?? "");
+        const content = body.length > 0 ? `${title}
+
+${body}` : title;
+        documents.push({
+          docId: item.id,
+          hierarchy,
+          title,
+          content: content.slice(0, MAX_CONTENT_CHARS4),
+          ...item.publishedAt !== undefined ? { publishedAt: item.publishedAt } : {},
+          metadata: { feedIndex: index, feedTitle, categories: item.categories }
+        });
+      }
+    }
+    if (failedFeeds === feeds.length) {
+      return { ok: false, reason: "unavailable", message: "all configured feeds failed" };
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+function normalizeFeed(parsed) {
+  const root = asRecord(parsed);
+  if (root === undefined)
+    return;
+  const channel = asRecord(asRecord(root.rss)?.channel);
+  if (channel !== undefined) {
+    const items = asArray(channel.item ?? []).concat(asRecord(channel.item) !== undefined ? [channel.item] : []);
+    return { title: textOf(channel.title), items: items.map(normalizeRssItem).filter(present) };
+  }
+  const atom = asRecord(root.feed);
+  if (atom !== undefined) {
+    const entries = asArray(atom.entry ?? []).concat(asRecord(atom.entry) !== undefined ? [atom.entry] : []);
+    return { title: textOf(atom.title), items: entries.map(normalizeAtomEntry).filter(present) };
+  }
+  return;
+}
+function normalizeRssItem(raw) {
+  const item = asRecord(raw);
+  if (item === undefined)
+    return;
+  const title = textOf(item.title);
+  const guid = textOf(item.guid) ?? textOf(item.link) ?? title;
+  if (guid === undefined)
+    return;
+  return {
+    id: guid,
+    title,
+    body: textOf(item.description),
+    publishedAt: parseEpochMs(textOf(item.pubDate)),
+    categories: categoriesOf(item.category)
+  };
+}
+function normalizeAtomEntry(raw) {
+  const entry = asRecord(raw);
+  if (entry === undefined)
+    return;
+  const title = textOf(entry.title);
+  const id = textOf(entry.id) ?? title;
+  if (id === undefined)
+    return;
+  return {
+    id,
+    title,
+    body: textOf(entry.summary) ?? textOf(entry.content),
+    publishedAt: parseEpochMs(textOf(entry.published) ?? textOf(entry.updated)),
+    categories: categoriesOf(entry.category)
+  };
+}
+function textOf(value) {
+  const direct = asString(value);
+  if (direct !== undefined)
+    return direct.trim();
+  if (typeof value === "number")
+    return String(value);
+  const record = asRecord(value);
+  if (record !== undefined) {
+    const text = asString(record["#text"]) ?? asString(record["@_term"]);
+    if (text !== undefined)
+      return text.trim();
+    if (typeof record["#text"] === "number")
+      return String(record["#text"]);
+  }
+  return;
+}
+function categoriesOf(value) {
+  const values = Array.isArray(value) ? value : value !== undefined ? [value] : [];
+  return values.map(textOf).filter((category) => category !== undefined && category.length > 0);
+}
+function stripHtml(text) {
+  return text.replace(/<[^>]+>/gu, " ").replace(/\s+/gu, " ").trim();
+}
+function present(item) {
+  return item !== undefined;
+}
+var DEFAULT_MAX_DOCUMENTS10 = 500, DEFAULT_MAX_ITEMS_PER_FEED = 100, DEFAULT_FEED_TIMEOUT_MS = 30000, MAX_CONTENT_CHARS4 = 20000, ACCEPT_HEADER = "application/rss+xml, application/atom+xml, application/xml, text/xml";
+var init_connector9 = () => {};
+
+// src/datasource/skills/rss/skill.ts
+var RSS_SKILL_DEFINITION, DEFAULT_DEDUPE_WINDOW_MS, RssSkill;
+var init_skill8 = __esm(() => {
+  init_connector_skill();
+  init_connector9();
+  RSS_SKILL_DEFINITION = {
+    skillName: "rss",
+    skillType: "rss-feeds",
+    description: "RSS/news datasource",
+    capabilities: ["news", "api", "polling"],
+    defaultTags: ["rss", "news", "public"],
+    contentType: "article",
+    manifestDescription: "Search indexed RSS/news feed articles from the configured feeds. Use for questions about recent news items or blog posts the server subscribes to.",
+    manifestNotes: ["Feeds are polled with a dedupe window so re-delivered items are indexed once per window."]
+  };
+  DEFAULT_DEDUPE_WINDOW_MS = 24 * 60 * 60 * 1000;
+  RssSkill = class RssSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(RSS_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new RssConnector(connectorOptions ?? {}),
+        dedupeWindowMs: options.dedupeWindowMs ?? DEFAULT_DEDUPE_WINDOW_MS
+      });
+    }
+  };
+});
+
+// src/datasource/skills/rss/index.ts
+var init_rss = __esm(() => {
+  init_connector9();
+  init_skill8();
+});
+
+// src/datasource/skills/slack/connector.ts
+class SlackConnector {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async fetch(signal) {
+    const token = resolveToken(this.options.token, this.options.tokenEnv ?? DEFAULT_TOKEN_ENV6);
+    if (token === undefined)
+      return { ok: false, reason: "not-configured", message: "auth token not configured" };
+    const baseUrl = this.options.baseUrl ?? DEFAULT_BASE_URL6;
+    const headers = { Authorization: `Bearer ${token}` };
+    const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES6;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS11;
+    const request = { headers, timeoutMs: this.options.timeoutMs, fetchImpl: this.options.fetchImpl, signal };
+    const channels = [];
+    let cursor;
+    for (let page = 0;page < maxPages; page += 1) {
+      const url = new URL(`${baseUrl}/conversations.list`);
+      url.searchParams.set("limit", "200");
+      url.searchParams.set("types", "public_channel,private_channel");
+      if (cursor !== undefined)
+        url.searchParams.set("cursor", cursor);
+      const result = await httpJson(url.toString(), request);
+      if (!result.ok)
+        return { ok: false, reason: result.reason, message: `channel list failed: ${result.message}` };
+      const envelope = asRecord(result.json);
+      if (envelope === undefined)
+        return { ok: false, reason: "invalid-data", message: "channel list malformed" };
+      if (envelope.ok !== true) {
+        const error = asString(envelope.error) ?? "unknown-error";
+        if (AUTH_ERRORS.has(error))
+          return { ok: false, reason: "auth", message: `slack: ${error}` };
+        if (error === "ratelimited")
+          return { ok: false, reason: "rate-limited", message: "slack: ratelimited" };
+        return { ok: false, reason: "api-error", message: `slack: ${error}` };
+      }
+      for (const raw of asArray(envelope.channels)) {
+        const channel = asRecord(raw);
+        const id = asString(channel?.id);
+        const name = asString(channel?.name);
+        if (id !== undefined && name !== undefined)
+          channels.push({ id, name });
+      }
+      cursor = asString(asRecord(envelope.response_metadata)?.next_cursor);
+      if (cursor === undefined || cursor.length === 0)
+        break;
+    }
+    const filter = this.options.channels;
+    const selected = filter === undefined || filter.length === 0 ? channels : channels.filter((channel) => filter.includes(channel.id) || filter.includes(channel.name));
+    const documents = [];
+    const warnings = [];
+    for (const channel of selected) {
+      if (documents.length >= maxDocuments)
+        break;
+      let historyCursor;
+      for (let page = 0;page < maxPages && documents.length < maxDocuments; page += 1) {
+        const url = new URL(`${baseUrl}/conversations.history`);
+        url.searchParams.set("channel", channel.id);
+        url.searchParams.set("limit", "200");
+        if (historyCursor !== undefined)
+          url.searchParams.set("cursor", historyCursor);
+        const result = await httpJson(url.toString(), request);
+        if (!result.ok) {
+          warnings.push(`channel ${channel.name} history failed: ${result.message}`);
+          break;
+        }
+        const envelope = asRecord(result.json);
+        if (envelope === undefined || envelope.ok !== true) {
+          const error = asString(envelope?.error) ?? "malformed response";
+          if (AUTH_ERRORS.has(error))
+            return { ok: false, reason: "auth", message: `slack: ${error}` };
+          if (error === "ratelimited")
+            return { ok: false, reason: "rate-limited", message: "slack: ratelimited" };
+          if (CHANNEL_SKIP_ERRORS.has(error))
+            warnings.push(`channel ${channel.name} skipped: ${error}`);
+          else
+            warnings.push(`channel ${channel.name} history failed: ${error}`);
+          break;
+        }
+        for (const raw of asArray(envelope.messages)) {
+          if (documents.length >= maxDocuments)
+            break;
+          const message = asRecord(raw);
+          if (message === undefined)
+            continue;
+          const text = asString(message.text);
+          const ts = asString(message.ts);
+          const subtype = asString(message.subtype);
+          if (text === undefined || text.length === 0 || ts === undefined)
+            continue;
+          if (subtype === "channel_join")
+            continue;
+          const user = asString(message.user) ?? asString(message.username) ?? "unknown";
+          documents.push({
+            docId: `${channel.id}-${ts.replace(/\./gu, "-")}`,
+            hierarchy: ["channels", channel.name],
+            title: `#${channel.name}`,
+            content: `${user}: ${text}`,
+            publishedAt: Math.round(Number.parseFloat(ts) * 1000),
+            metadata: { channelId: channel.id, ts, user }
+          });
+        }
+        historyCursor = asString(asRecord(envelope.response_metadata)?.next_cursor);
+        if (historyCursor === undefined || historyCursor.length === 0)
+          break;
+      }
+    }
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+var DEFAULT_BASE_URL6 = "https://slack.com/api", DEFAULT_TOKEN_ENV6 = "SLACK_BOT_TOKEN", DEFAULT_MAX_PAGES6 = 10, DEFAULT_MAX_DOCUMENTS11 = 500, AUTH_ERRORS, CHANNEL_SKIP_ERRORS;
+var init_connector10 = __esm(() => {
+  AUTH_ERRORS = new Set(["invalid_auth", "not_authed", "token_revoked", "account_inactive"]);
+  CHANNEL_SKIP_ERRORS = new Set(["missing_scope", "access_denied", "channel_not_found", "not_in_channel"]);
+});
+
+// src/datasource/skills/slack/skill.ts
+var SLACK_SKILL_DEFINITION, SlackSkill;
+var init_skill9 = __esm(() => {
+  init_connector_skill();
+  init_connector10();
+  SLACK_SKILL_DEFINITION = {
+    skillName: "slack",
+    skillType: "slack-workspace",
+    description: "Slack workspace datasource",
+    capabilities: ["chat", "api", "polling"],
+    defaultTags: ["slack", "chat", "pii"],
+    contentType: "chat",
+    manifestDescription: "Search indexed Slack messages across authorized workspace channels. Use for questions about Slack conversations, decisions made in channels, or who said what.",
+    manifestNotes: [
+      "Message history windows and channel visibility are bounded by the server-configured bot token scopes."
+    ]
+  };
+  SlackSkill = class SlackSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(SLACK_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new SlackConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/slack/index.ts
+var init_slack = __esm(() => {
+  init_connector10();
+  init_skill9();
+});
+
+// src/datasource/skills/spotlight/connector.ts
+import { spawn as spawn3 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as fsReadFile, stat as stat3 } from "node:fs/promises";
+import { basename as basename3, extname as extname3 } from "node:path";
+
+class SpotlightConnector {
+  options;
+  run;
+  readFile;
+  platform;
+  constructor(options = {}) {
+    this.options = options;
+    this.run = options.run ?? spawnRunner;
+    this.readFile = options.readFile ?? ((path) => fsReadFile(path, "utf8"));
+    this.platform = options.platform ?? process.platform;
+  }
+  async fetch() {
+    if (this.platform !== "darwin") {
+      return { ok: false, reason: "unavailable", message: "spotlight datasource is supported on macOS only" };
+    }
+    const queries = (this.options.queries ?? []).map((query) => query.trim()).filter((query) => query.length > 0);
+    if (queries.length === 0) {
+      return { ok: false, reason: "not-configured", message: "no spotlight queries configured" };
+    }
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS4;
+    const status = await this.run("mdutil", ["-s", "/"], timeoutMs);
+    if (status.ok && /indexing disabled/iu.test(status.stdout)) {
+      return {
+        ok: false,
+        reason: "unavailable",
+        message: "Spotlight indexing is disabled; enable it with `sudo mdutil -i on /`"
+      };
+    }
+    const maxPerQuery = this.options.maxResultsPerQuery ?? DEFAULT_MAX_RESULTS_PER_QUERY;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS12;
+    const seen = new Set;
+    const paths = [];
+    let mdfindMissing = false;
+    let failedQueries = 0;
+    for (const query of queries) {
+      const args = this.options.onlyIn !== undefined ? ["-onlyin", this.options.onlyIn, query] : [query];
+      const result = await this.run("mdfind", args, timeoutMs);
+      if (!result.ok) {
+        if (result.error === "ENOENT") {
+          mdfindMissing = true;
+          break;
+        }
+        failedQueries += 1;
+        continue;
+      }
+      let kept = 0;
+      for (const line of result.stdout.split(`
+`)) {
+        const path = line.trim();
+        if (path.length === 0 || seen.has(path))
+          continue;
+        if (kept >= maxPerQuery)
+          break;
+        seen.add(path);
+        paths.push(path);
+        kept += 1;
+      }
+    }
+    if (mdfindMissing) {
+      return { ok: false, reason: "unavailable", message: "mdfind binary not found; Spotlight requires macOS" };
+    }
+    if (failedQueries === queries.length) {
+      return { ok: false, reason: "unavailable", message: "every configured mdfind query failed" };
+    }
+    const maxBytes = this.options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE4;
+    const documents = [];
+    let permissionDenied = 0;
+    let readFailures = 0;
+    for (const path of paths) {
+      if (documents.length >= maxDocuments)
+        break;
+      try {
+        const info = await stat3(path);
+        if (!info.isFile() || info.size > maxBytes)
+          continue;
+        const text = await this.readFile(path);
+        const content = text.trim().slice(0, MAX_CONTENT_CHARS5);
+        if (content.length === 0)
+          continue;
+        documents.push({
+          docId: createHash2("sha256").update(path).digest("hex").slice(0, 16),
+          hierarchy: ["files"],
+          title: basename3(path),
+          content,
+          publishedAt: info.mtimeMs,
+          metadata: { path, extension: extname3(path).toLowerCase() }
+        });
+      } catch (error) {
+        const code = error.code;
+        if (code === "EPERM" || code === "EACCES")
+          permissionDenied += 1;
+        else
+          readFailures += 1;
+      }
+    }
+    if (documents.length === 0 && permissionDenied > 0) {
+      return {
+        ok: false,
+        reason: "permission",
+        message: `macOS denied access to all Spotlight hits; ${FDA_GUIDANCE}`
+      };
+    }
+    const warnings = [];
+    if (failedQueries > 0)
+      warnings.push(`${failedQueries} mdfind quer(y/ies) failed`);
+    if (permissionDenied > 0) {
+      warnings.push(`${permissionDenied} Spotlight hit(s) were denied by macOS privacy protections; ${FDA_GUIDANCE}`);
+    }
+    if (readFailures > 0)
+      warnings.push(`${readFailures} Spotlight hit(s) failed to read`);
+    return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
+  }
+}
+var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS12 = 300, DEFAULT_MAX_BYTES_PER_FILE4, DEFAULT_TIMEOUT_MS4 = 15000, MAX_CONTENT_CHARS5 = 1e5, MAX_BUFFER_BYTES, FDA_GUIDANCE = "grant Full Disk Access to the terminal or app running AutoRAG (System Settings -> Privacy & Security -> Full Disk Access), then restart it", spawnRunner = (command, args, timeoutMs) => new Promise((resolve2) => {
+  const child = spawn3(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
+  let stdout = "";
+  let stderr = "";
+  let settled = false;
+  const finish = (result) => {
+    if (settled)
+      return;
+    settled = true;
+    clearTimeout(timer);
+    resolve2(result);
+  };
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    finish({ ok: false, stdout, stderr: "process timed out", code: null });
+  }, timeoutMs);
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    if (stdout.length < MAX_BUFFER_BYTES)
+      stdout += chunk;
+  });
+  child.stderr.on("data", (chunk) => {
+    if (stderr.length < MAX_BUFFER_BYTES)
+      stderr += chunk;
+  });
+  child.on("error", (error) => {
+    finish({ ok: false, stdout, stderr: error.message, code: null, error: error.code });
+  });
+  child.on("close", (code) => {
+    finish({ ok: code === 0, stdout, stderr, code });
+  });
+});
+var init_connector11 = __esm(() => {
+  DEFAULT_MAX_BYTES_PER_FILE4 = 256 * 1024;
+  MAX_BUFFER_BYTES = 4 * 1024 * 1024;
+});
+
+// src/datasource/skills/spotlight/skill.ts
+var SPOTLIGHT_SKILL_DEFINITION, SpotlightSkill;
+var init_skill10 = __esm(() => {
+  init_connector_skill();
+  init_connector11();
+  SPOTLIGHT_SKILL_DEFINITION = {
+    skillName: "spotlight",
+    skillType: "spotlight-search",
+    description: "macOS Spotlight datasource",
+    capabilities: ["files", "macos-only", "local-search"],
+    defaultTags: ["spotlight", "files"],
+    contentType: "document",
+    manifestDescription: "Search files indexed by macOS Spotlight via the built-in mdfind CLI. macOS only; no external installs. Use for questions about local documents on the Mac running AutoRAG.",
+    manifestNotes: [
+      "## Platform requirements",
+      "- macOS only: this datasource is unavailable on any other platform.",
+      "- Spotlight indexing must be enabled (`sudo mdutil -i on /`; check with `mdutil -s /`).",
+      "- **Full Disk Access**: Spotlight can find protected files (Mail, Messages, Safari data, parts of ~/Library), but reading their content fails unless the terminal or app running AutoRAG has Full Disk Access. Grant it under System Settings -> Privacy & Security -> Full Disk Access, add the host app (e.g. Terminal, iTerm, or the AutoRAG binary), then restart the app. Permission failures surface as `datasource-permission-denied`.",
+      "",
+      "## Operator cheat sheet",
+      "- `mdfind <query>` — Spotlight search; `mdfind -onlyin <dir> <query>` scopes to a directory; `mdfind -name <text>` matches file names.",
+      "- `mdls <file>` — show Spotlight metadata attributes (kMDItemDisplayName, kMDItemContentType, …) for one file.",
+      "- `mdutil -s /` — index status; `sudo mdutil -i on /` / `-i off /` — enable/disable indexing; `sudo mdutil -E /` — erase and rebuild the index.",
+      "",
+      "Queries are trusted server configuration; indexing re-runs the configured mdfind queries and hydrates text content. Result metadata carries the real absolute file path (`path`) so hits are traceable back to disk; if paths must not leave this machine, run AutoRAG with a local LLM."
+    ]
+  };
+  SpotlightSkill = class SpotlightSkill extends ConnectorDatasourceSkill {
+    constructor(options = {}) {
+      const { connector, connectorOptions, ...rest } = options;
+      super(SPOTLIGHT_SKILL_DEFINITION, {
+        ...rest,
+        connector: connector ?? new SpotlightConnector(connectorOptions ?? {})
+      });
+    }
+  };
+});
+
+// src/datasource/skills/spotlight/index.ts
+var init_spotlight = __esm(() => {
+  init_connector11();
+  init_skill10();
+});
+
+// src/datasource/skills/factory.ts
+function common(config, workspaceRoot) {
+  return {
+    ...config.instanceId !== undefined ? { instanceId: config.instanceId } : {},
+    ...config.pollingIntervalMs !== undefined ? { pollingIntervalMs: config.pollingIntervalMs } : {},
+    ...config.tags !== undefined ? { tags: config.tags } : {},
+    ...workspaceRoot !== undefined ? { workspaceRoot } : {}
+  };
+}
+function buildDatasourceSkills(config, workspaceRoot) {
+  const skills = [];
+  const unknown = [];
+  for (const [name, raw] of Object.entries(config ?? {})) {
+    if (raw === false)
+      continue;
+    const entry = raw === true ? {} : raw;
+    if (entry.enabled === false)
+      continue;
+    const builder = BUILDERS[name];
+    if (builder === undefined) {
+      unknown.push(name);
+      continue;
+    }
+    skills.push(builder(entry, workspaceRoot));
+  }
+  return { skills, unknown };
+}
+var BUILDERS, BUILTIN_DATASOURCE_SKILL_NAMES;
+var init_factory = __esm(() => {
+  init_discord();
+  init_gdrive();
+  init_rclone_connector();
+  init_github();
+  init_himalaya_connector();
+  init_gmail();
+  init_mail_export();
+  init_notion();
+  init_obsidian();
+  init_rss();
+  init_slack();
+  init_spotlight();
+  BUILDERS = {
+    slack: (config, workspaceRoot) => new SlackSkill({ ...common(config, workspaceRoot), connectorOptions: config.connector }),
+    discord: (config, workspaceRoot) => new DiscordSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    }),
+    notion: (config, workspaceRoot) => new NotionSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    }),
+    github: (config, workspaceRoot) => new GitHubSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    }),
+    gdrive: (config, workspaceRoot) => {
+      const connector = config.connector;
+      if (connector?.backend === "rclone") {
+        const { backend: _backend, ...rcloneOptions } = connector;
+        return new GDriveSkill({
+          ...common(config, workspaceRoot),
+          connector: new RcloneConnector(rcloneOptions)
+        });
+      }
+      return new GDriveSkill({
+        ...common(config, workspaceRoot),
+        connectorOptions: connector
+      });
+    },
+    gmail: (config, workspaceRoot) => {
+      const connector = config.connector;
+      if (connector?.backend === "himalaya") {
+        const { backend: _backend, ...himalayaOptions } = connector;
+        return new GmailSkill({
+          ...common(config, workspaceRoot),
+          connector: new HimalayaConnector(himalayaOptions)
+        });
+      }
+      return new GmailSkill({ ...common(config, workspaceRoot), connectorOptions: connector });
+    },
+    "mail-export": (config, workspaceRoot) => new MailExportSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    }),
+    obsidian: (config, workspaceRoot) => new ObsidianSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    }),
+    rss: (config, workspaceRoot) => new RssSkill({ ...common(config, workspaceRoot), connectorOptions: config.connector }),
+    spotlight: (config, workspaceRoot) => new SpotlightSkill({
+      ...common(config, workspaceRoot),
+      connectorOptions: config.connector
+    })
+  };
+  BUILTIN_DATASOURCE_SKILL_NAMES = Object.keys(BUILDERS);
+});
+
 // src/filesystem/file-lock.ts
 import { randomUUID } from "node:crypto";
 import {
   closeSync,
   lstatSync,
-  mkdirSync,
+  mkdirSync as mkdirSync2,
   openSync,
   readdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   rmdirSync,
   unlinkSync,
   writeSync
 } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join5 } from "node:path";
 function hasErrorCode(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
@@ -413,7 +3068,7 @@ function inspectRegularFile(path) {
     return { kind: "other" };
   let contents;
   try {
-    contents = readFileSync(path, "utf8");
+    contents = readFileSync2(path, "utf8");
   } catch (error) {
     if (hasErrorCode(error, "ENOENT"))
       return { kind: "missing" };
@@ -504,7 +3159,7 @@ function reapStaleLockDirectory(lockPath, staleMs) {
     return removeEmptyLockDirectory(lockPath);
   const staleSnapshots = [];
   for (const name of names) {
-    const inspection = inspectRegularFile(join2(lockPath, name));
+    const inspection = inspectRegularFile(join5(lockPath, name));
     if (inspection.kind === "missing")
       continue;
     if (inspection.kind !== "file" || !isStaleSnapshot(inspection, staleMs))
@@ -559,14 +3214,14 @@ function createLockFile(lockPath, contents) {
 }
 function tryCreateOwnerMarker(lockPath, owner, contents) {
   try {
-    mkdirSync(lockPath, { mode: 448 });
+    mkdirSync2(lockPath, { mode: 448 });
   } catch (error) {
     if (hasErrorCode(error, "EEXIST"))
       return;
     throw error;
   }
   const markerName = `owner-${owner.token}.json`;
-  const markerPath = join2(lockPath, markerName);
+  const markerPath = join5(lockPath, markerName);
   let acquired = false;
   try {
     try {
@@ -651,9 +3306,9 @@ var init_file_lock = __esm(() => {
 });
 
 // src/subagents/local-models.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join6 } from "node:path";
 import { parse } from "smol-toml";
 function createModel(provider, baseUrl, id, defaultId, defaultName) {
   return {
@@ -670,8 +3325,8 @@ function createModel(provider, baseUrl, id, defaultId, defaultName) {
   };
 }
 function loadLocalAutoRAGModels(options = {}) {
-  const configPath = options.configPath ?? join3(homedir2(), ".codex", "config.toml");
-  const config = parse(readFileSync2(configPath, "utf8"));
+  const configPath = options.configPath ?? join6(homedir2(), ".codex", "config.toml");
+  const config = parse(readFileSync3(configPath, "utf8"));
   const provider = config.model_provider;
   if (typeof provider !== "string" || provider.length === 0) {
     throw new Error(`AutoRAG requires model_provider in ${configPath}`);
@@ -702,8 +3357,8 @@ var init_local_models = () => {};
 
 // src/cli/config.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
-import { basename, dirname, isAbsolute as isAbsolute2, join as join4, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename as basename4, dirname as dirname3, isAbsolute as isAbsolute2, join as join7, resolve as resolve2 } from "node:path";
 import { findEnvKeys, getEnvApiKey, getModel, getProviders } from "@earendil-works/pi-ai/compat";
 function resolveConfigPath(input) {
   const flags = input.flags;
@@ -718,15 +3373,15 @@ function resolveConfigPath(input) {
     return { configPath: envConfig, explicit: true };
   }
   return {
-    configPath: join4(resolveAutoRAGHome(env), DEFAULT_CONFIG_FILENAME),
+    configPath: join7(resolveAutoRAGHome(env), DEFAULT_CONFIG_FILENAME),
     explicit: false,
-    legacyPath: join4(cwd, LEGACY_CONFIG_FILENAME)
+    legacyPath: join7(cwd, LEGACY_CONFIG_FILENAME)
   };
 }
 function readConfigFile(configPath, explicit) {
   let exists;
   try {
-    exists = existsSync(configPath);
+    exists = existsSync2(configPath);
   } catch {
     exists = false;
   }
@@ -738,7 +3393,7 @@ function readConfigFile(configPath, explicit) {
   }
   let text;
   try {
-    text = readFileSync3(configPath, "utf8");
+    text = readFileSync4(configPath, "utf8");
   } catch (err) {
     throw new ConfigError(`Failed to read config file: ${err.message}`);
   }
@@ -776,9 +3431,9 @@ function acquireConfigWriteLock(configPath) {
   });
 }
 function replaceFileAtomically(path, contents, assertCommitAllowed) {
-  const temporaryPath = join4(dirname(path), `.${basename(path)}.${process.pid}.${randomUUID2()}.tmp`);
+  const temporaryPath = join7(dirname3(path), `.${basename4(path)}.${process.pid}.${randomUUID2()}.tmp`);
   try {
-    writeFileSync(temporaryPath, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
+    writeFileSync2(temporaryPath, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
     assertCommitAllowed?.();
     renameSync(temporaryPath, path);
   } finally {
@@ -786,14 +3441,14 @@ function replaceFileAtomically(path, contents, assertCommitAllowed) {
   }
 }
 function migrateLegacyConfig(configPath, legacyPath) {
-  if (existsSync(configPath) || !existsSync(legacyPath))
+  if (existsSync2(configPath) || !existsSync2(legacyPath))
     return;
   const legacy = readConfigFile(legacyPath, true);
-  const legacyBytes = readFileSync3(legacyPath);
-  const migrated = normalizeLegacyConfigPaths(legacy ?? {}, dirname(legacyPath));
+  const legacyBytes = readFileSync4(legacyPath);
+  const migrated = normalizeLegacyConfigPaths(legacy ?? {}, dirname3(legacyPath));
   const migratedBytes = legacy?.workspacePath === migrated.workspacePath && legacy?.memoryPath === migrated.memoryPath && JSON.stringify(legacy?.searchPaths) === JSON.stringify(migrated.searchPaths) ? legacyBytes : `${JSON.stringify(migrated, null, 2)}
 `;
-  mkdirSync2(dirname(configPath), { recursive: true });
+  mkdirSync3(dirname3(configPath), { recursive: true });
   const lock = acquireConfigWriteLock(configPath);
   try {
     const winner = readConfigFile(configPath, false);
@@ -823,7 +3478,7 @@ function resolveConfigFileReadOnly(configPath, explicit, legacyPath) {
   const legacy = readConfigFile(legacyPath, false);
   if (legacy === undefined)
     return {};
-  return normalizeLegacyConfigPaths(legacy, dirname(legacyPath));
+  return normalizeLegacyConfigPaths(legacy, dirname3(legacyPath));
 }
 function resolveSearchPaths(searchPaths, origin) {
   return searchPaths.map((searchPath) => resolvePersistedPath(searchPath, origin));
@@ -1092,10 +3747,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 = join4(resolveAutoRAGHome(env), "memory.json");
+  const defaultMemoryPath = join7(resolveAutoRAGHome(env), "memory.json");
   const flagSearchPaths = parseCsv(flagString(flags, "search-paths"));
   const envSearchPaths = parseCsv(envString(env, "AUTORAG_SEARCH_PATHS"));
-  const configOrigin = dirname(resolve2(configPath));
+  const configOrigin = dirname3(resolve2(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;
@@ -1138,6 +3793,18 @@ function resolveConfig(input) {
     config.jikji = file.jikji;
   if (file.parserOptions)
     config.parserOptions = file.parserOptions;
+  if (file.datasources !== undefined) {
+    if (typeof file.datasources !== "object" || file.datasources === null || Array.isArray(file.datasources)) {
+      throw new ConfigError("Config field 'datasources' must be an object mapping skill names to their config");
+    }
+    config.datasources = file.datasources;
+  }
+  if (file.datasourceAccess !== undefined) {
+    if (typeof file.datasourceAccess !== "object" || file.datasourceAccess === null || Array.isArray(file.datasourceAccess)) {
+      throw new ConfigError("Config field 'datasourceAccess' must be an object with allowedTags/allowedScopes");
+    }
+    config.datasourceAccess = file.datasourceAccess;
+  }
   return config;
 }
 function resolveConfigReadOnly(input) {
@@ -1167,6 +3834,16 @@ function buildAgentOptions(config) {
     opts.jikji = config.jikji;
   if (config.parserOptions)
     opts.parserOptions = config.parserOptions;
+  if (config.datasources !== undefined) {
+    const { skills, unknown } = buildDatasourceSkills(config.datasources, config.workspacePath);
+    if (unknown.length > 0) {
+      throw new ConfigError(`Unknown datasource skill(s) in config: ${unknown.join(", ")}`);
+    }
+    if (skills.length > 0)
+      opts.datasourceSkills = skills;
+  }
+  if (config.datasourceAccess !== undefined)
+    opts.datasourceAccess = config.datasourceAccess;
   return opts;
 }
 function isConfiguredEndpoint(reference) {
@@ -1385,7 +4062,7 @@ function resolveAgentModelDetailed(config, localOptions = {}) {
 function writeDefaultConfig(path, partial, opts = {}) {
   const cwd = resolve2(opts.cwd ?? process.cwd());
   const workspacePath = resolvePersistedPath(partial.workspacePath ?? ".", cwd);
-  const memoryPath = partial.memoryPath === undefined ? join4(resolveAutoRAGHome(opts.env), "memory.json") : resolvePersistedPath(partial.memoryPath, workspacePath);
+  const memoryPath = partial.memoryPath === undefined ? join7(resolveAutoRAGHome(opts.env), "memory.json") : resolvePersistedPath(partial.memoryPath, workspacePath);
   const full = {
     searchPaths: resolveSearchPaths(partial.searchPaths ?? ["."], cwd),
     workspacePath,
@@ -1410,19 +4087,19 @@ function writeDefaultConfig(path, partial, opts = {}) {
   full.jikji = partial.jikji ?? {};
   if (partial.parserOptions)
     full.parserOptions = partial.parserOptions;
-  mkdirSync2(dirname(path), { recursive: true });
+  mkdirSync3(dirname3(path), { recursive: true });
   const contents = `${JSON.stringify(full, null, 2)}
 `;
   const lock = acquireConfigWriteLock(path);
   try {
-    if (!opts.force && existsSync(path)) {
+    if (!opts.force && existsSync2(path)) {
       throw new ConfigError(`Config file already exists: ${path}`);
     }
     if (opts.force || opts.atomicCreate)
       replaceFileAtomically(path, contents, lock.assertOwned);
     else {
       lock.assertOwned();
-      writeFileSync(path, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
+      writeFileSync2(path, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
     }
   } catch (error) {
     if (!opts.force && isEexistError(error)) {
@@ -1436,6 +4113,7 @@ function writeDefaultConfig(path, partial, opts = {}) {
 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_PATTERN, POSITIVE_INT_FIELDS, EMBEDDER_ALLOWLIST, BM25_ALLOWLIST, MINSYNC_ALLOWLIST;
 var init_config = __esm(() => {
   init_home();
+  init_factory();
   init_file_lock();
   init_local_models();
   init_home();
@@ -1483,8 +4161,8 @@ var exports_init = {};
 __export(exports_init, {
   runInit: () => runInit
 });
-import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
 async function runInit(ctx) {
   const flags = ctx.flags;
   const partial = {};
@@ -1532,12 +4210,12 @@ async function runInit(ctx) {
     throw error;
   }
   const resolvedPath = resolveConfigPath({ flags, cwd: ctx.cwd });
-  const migratingLegacy = !resolvedPath.explicit && resolvedPath.legacyPath !== undefined && existsSync2(resolvedPath.legacyPath) && !existsSync2(resolvedPath.configPath);
+  const migratingLegacy = !resolvedPath.explicit && resolvedPath.legacyPath !== undefined && existsSync3(resolvedPath.legacyPath) && !existsSync3(resolvedPath.configPath);
   if (migratingLegacy) {
     try {
       const legacyPath = resolvedPath.legacyPath;
-      const legacy = JSON.parse(readFileSync4(legacyPath, "utf8"));
-      const normalizedLegacy = normalizeLegacyConfigPaths(legacy, dirname2(legacyPath));
+      const legacy = JSON.parse(readFileSync5(legacyPath, "utf8"));
+      const normalizedLegacy = normalizeLegacyConfigPaths(legacy, dirname4(legacyPath));
       partial.searchPaths ??= normalizedLegacy.searchPaths;
       partial.workspacePath ??= normalizedLegacy.workspacePath;
       partial.memoryPath ??= normalizedLegacy.memoryPath;
@@ -1623,49 +4301,6 @@ var init_init = __esm(() => {
   init_config();
 });
 
-// src/retrieval/scope.ts
-function normalizeVirtualPath(value) {
-  const normalized = value.replace(/\\/g, "/").replace(/\/+/g, "/").trim();
-  if (normalized.length === 0 || normalized === "/")
-    return "/";
-  const withLeadingSlash = normalized.startsWith("/") ? normalized : `/${normalized}`;
-  return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/g, "") : withLeadingSlash;
-}
-function normalizeVirtualPathScope(scope) {
-  if (scope === undefined)
-    return;
-  const normalized = normalizeVirtualPath(scope);
-  return normalized === "/" ? undefined : normalized;
-}
-function matchesVirtualPathScope(virtualPath, scope) {
-  const normalizedScope = normalizeVirtualPathScope(scope);
-  if (normalizedScope === undefined)
-    return true;
-  return virtualPathScopeToRegExp(normalizedScope).test(normalizeVirtualPath(virtualPath));
-}
-function virtualPathScopeToRegExp(scope) {
-  const normalized = normalizeVirtualPath(scope);
-  const scoped = hasGlob(normalized) || looksLikeFileScope(normalized) ? normalized : `${normalized}/**`;
-  const pattern = scoped.split("/").map((segment, index) => {
-    if (index === 0)
-      return "";
-    if (segment === "**")
-      return "(?:.*)";
-    return escapeRegExp(segment).replace(/\\\*/g, "[^/]*");
-  }).join("/").replace(/\/\(\?:\.\*\)$/u, "(?:/.*)?");
-  return new RegExp(`^${pattern}$`);
-}
-function hasGlob(scope) {
-  return scope.includes("*");
-}
-function looksLikeFileScope(scope) {
-  const finalSegment = scope.split("/").at(-1) ?? "";
-  return /\.[^/.]+$/u.test(finalSegment);
-}
-function escapeRegExp(literal) {
-  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 // src/datasource/access-context.ts
 class DatasourceAccessContext {
   allowedTags;
@@ -1817,7 +4452,7 @@ var init_diagnostics = __esm(() => {
 
 // src/jikji/answer-pack.ts
 import { realpathSync } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join5, relative, resolve as resolve3 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join8, relative as relative2, resolve as resolve3 } from "node:path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1942,10 +4577,10 @@ function normalizeJikjiAnswerPath(rawPath, sourceRoots) {
     } catch {
       continue;
     }
-    const rel = relative(realRoot, realCandidate);
+    const rel = relative2(realRoot, realCandidate);
     if (rel.startsWith("..") || isAbsolute3(rel))
       continue;
-    return join5(root.rootPath, rel);
+    return join8(root.rootPath, rel);
   }
   return;
 }
@@ -1959,9 +4594,9 @@ var init_answer_pack = __esm(() => {
 });
 
 // src/jikji/installer.ts
-import { spawn } from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
-import { delimiter, join as join6 } from "node:path";
+import { spawn as spawn4 } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import { delimiter, join as join9 } from "node:path";
 function jikjiExecutableName(platform = process.platform) {
   return platform === "win32" ? "jikji.exe" : "jikji";
 }
@@ -1969,7 +4604,7 @@ function cargoExecutableName(platform = process.platform) {
   return platform === "win32" ? "cargo.exe" : "cargo";
 }
 function cachedJikjiBinaryPath(root, platform = process.platform) {
-  return join6(root, ".autorag", "bin", jikjiExecutableName(platform));
+  return join9(root, ".autorag", "bin", jikjiExecutableName(platform));
 }
 function lookupExecutableInPath(executable, env) {
   const pathEnv = env.PATH;
@@ -1978,15 +4613,15 @@ function lookupExecutableInPath(executable, env) {
   for (const dir of pathEnv.split(delimiter)) {
     if (dir.length === 0)
       continue;
-    const candidate = join6(dir, executable);
-    if (existsSync3(candidate))
+    const candidate = join9(dir, executable);
+    if (existsSync4(candidate))
       return candidate;
   }
   return;
 }
 function defaultRunner(cargo, env) {
   return (args, timeoutMs) => new Promise((resolvePromise) => {
-    const child = spawn(cargo, args, { env, stdio: ["ignore", "ignore", "pipe"] });
+    const child = spawn4(cargo, args, { env, stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     const timeout = setTimeout(() => {
       if (!child.killed)
@@ -2009,7 +4644,7 @@ function defaultRunner(cargo, env) {
 async function ensureJikjiBinary(options) {
   const env = options.env ?? process.env;
   const cached = cachedJikjiBinaryPath(options.root);
-  if (existsSync3(cached))
+  if (existsSync4(cached))
     return { ok: true, binaryPath: cached, source: "cached" };
   const cargoLocator = options.cargoLocator ?? ((e) => lookupExecutableInPath(cargoExecutableName(), e));
   const cargo = cargoLocator(env);
@@ -2020,12 +4655,12 @@ async function ensureJikjiBinary(options) {
       message: "Jikji auto-install needs the Rust toolchain (cargo) on PATH — install via https://rustup.rs, or install jikji manually (`cargo install jikji-cli`)."
     };
   }
-  const args = ["install", JIKJI_CRATE_NAME, "--locked", "--root", join6(options.root, ".autorag")];
+  const args = ["install", JIKJI_CRATE_NAME, "--locked", "--root", join9(options.root, ".autorag")];
   if (options.version !== undefined)
     args.push("--version", options.version);
   const runner = options.runner ?? defaultRunner(cargo, env);
   const result = await runner(args, options.timeoutMs ?? JIKJI_INSTALL_TIMEOUT_MS);
-  if (result.code === 0 && existsSync3(cached)) {
+  if (result.code === 0 && existsSync4(cached)) {
     return { ok: true, binaryPath: cached, source: "installed" };
   }
   return {
@@ -2040,8 +4675,8 @@ var init_installer = __esm(() => {
 });
 
 // src/jikji/client.ts
-import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync4 } from "node:fs";
+import { spawn as spawn5 } from "node:child_process";
+import { existsSync as existsSync5 } from "node:fs";
 
 class JikjiClient {
   options;
@@ -2054,13 +4689,13 @@ class JikjiClient {
       return commandFor(this.options.binaryPath);
     if (this.resolvedCommand !== undefined)
       return this.resolvedCommand;
-    if (lookupExecutableInPath(DEFAULT_BINARY, process.env) !== undefined) {
-      this.resolvedCommand = DEFAULT_BINARY;
+    if (lookupExecutableInPath(DEFAULT_BINARY3, process.env) !== undefined) {
+      this.resolvedCommand = DEFAULT_BINARY3;
       return this.resolvedCommand;
     }
     if (this.options.root !== undefined) {
       const cached = cachedJikjiBinaryPath(this.options.root);
-      if (existsSync4(cached)) {
+      if (existsSync5(cached)) {
         this.resolvedCommand = cached;
         return this.resolvedCommand;
       }
@@ -2072,7 +4707,7 @@ class JikjiClient {
         }
       }
     }
-    this.resolvedCommand = DEFAULT_BINARY;
+    this.resolvedCommand = DEFAULT_BINARY3;
     return this.resolvedCommand;
   }
   async prepare(root, options = {}) {
@@ -2136,7 +4771,7 @@ class JikjiClient {
 function spawnJikji(request) {
   return new Promise((resolve4) => {
     const options = request.options;
-    const child = spawn2(request.command, request.args, {
+    const child = spawn5(request.command, request.args, {
       env: controlledEnv(options.env),
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -2147,7 +4782,7 @@ function spawnJikji(request) {
     const timeout = setTimeout(() => {
       finalReason = "timeout";
       terminate(child);
-    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS5);
     const abortHandler = () => {
       finalReason = "aborted";
       terminate(child);
@@ -2194,7 +4829,7 @@ function spawnJikji(request) {
   });
 }
 function commandFor(binaryPath) {
-  return binaryPath === undefined || binaryPath === DEFAULT_BINARY ? DEFAULT_BINARY : binaryPath;
+  return binaryPath === undefined || binaryPath === DEFAULT_BINARY3 ? DEFAULT_BINARY3 : binaryPath;
 }
 function buildPrepareArgs(options, root) {
   const args = ["prepare", root, "--json"];
@@ -2261,19 +4896,19 @@ function appendBounded(state, chunk, maxBytes) {
   const remainingBytes = Math.max(maxBytes - state.bytes, 0);
   return { text: state.text + chunk.slice(0, remainingBytes), bytes: maxBytes, capped: true };
 }
-var DEFAULT_BINARY = "jikji", DEFAULT_TIMEOUT_MS = 1e4, DEFAULT_MAX_BUFFER_BYTES = 1048576;
+var DEFAULT_BINARY3 = "jikji", DEFAULT_TIMEOUT_MS5 = 1e4, DEFAULT_MAX_BUFFER_BYTES = 1048576;
 var init_client = __esm(() => {
   init_answer_pack();
   init_installer();
 });
 
 // src/filesystem/source-paths.ts
-import { basename as basename2, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve4, sep } from "node:path";
+import { basename as basename5, isAbsolute as isAbsolute4, relative as relative3, resolve as resolve4, sep as sep2 } from "node:path";
 function planSourceRoots(searchPaths) {
   const sorted = searchPaths.map((path) => resolve4(path)).sort((a, b) => a.localeCompare(b));
   const used = new Set;
   return sorted.map((rootPath) => {
-    const base = basename2(rootPath.replace(/[/\\]+$/, "")) || "root";
+    const base = basename5(rootPath.replace(/[/\\]+$/, "")) || "root";
     let prefix = `/${base}`;
     let suffix = 2;
     while (used.has(prefix)) {
@@ -2285,14 +4920,14 @@ function planSourceRoots(searchPaths) {
   });
 }
 function sourceIdentifier(sourceRoot, sourcePath) {
-  const rel = relative2(sourceRoot.rootPath, resolve4(sourcePath));
-  const suffix = rel === "" ? "" : `/${rel.split(sep).join("/")}`;
+  const rel = relative3(sourceRoot.rootPath, resolve4(sourcePath));
+  const suffix = rel === "" ? "" : `/${rel.split(sep2).join("/")}`;
   return `${sourceRoot.prefix}${suffix}`;
 }
 var init_source_paths = () => {};
 
 // src/jikji/path-map.ts
-import { isAbsolute as isAbsolute5, relative as relative3, resolve as resolve5, sep as sep2 } from "node:path";
+import { isAbsolute as isAbsolute5, relative as relative4, resolve as resolve5, sep as sep3 } from "node:path";
 function planJikjiSourceRoots(searchPaths) {
   return planSourceRoots(searchPaths).map((sourceRoot) => ({
     ...sourceRoot,
@@ -2319,8 +4954,8 @@ function isUnsafeReturnedPath(normalizedPath) {
   return normalizedPath.startsWith("/") || /^[A-Za-z]:\//.test(normalizedPath) || normalizedPath.startsWith("//") || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(normalizedPath);
 }
 function isWithinRoot(rootPath, sourcePath) {
-  const rel = relative3(resolve5(rootPath), resolve5(sourcePath));
-  return rel === "" || !rel.startsWith("..") && !rel.includes(`..${sep2}`) && !isAbsolute5(rel);
+  const rel = relative4(resolve5(rootPath), resolve5(sourcePath));
+  return rel === "" || !rel.startsWith("..") && !rel.includes(`..${sep3}`) && !isAbsolute5(rel);
 }
 var init_path_map = __esm(() => {
   init_source_paths();
@@ -2353,8 +4988,8 @@ var init_jikji = __esm(() => {
 });
 
 // src/manifest/loader.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "node:fs";
-import { extname, join as join7 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "node:fs";
+import { extname as extname4, join as join10 } from "node:path";
 import { parse as parseYaml } from "yaml";
 function isValidManifest(data) {
   if (typeof data !== "object" || data === null)
@@ -2363,8 +4998,8 @@ function isValidManifest(data) {
   return typeof obj.name === "string" && obj.name.length > 0 && typeof obj.description === "string" && obj.description.length > 0 && typeof obj.type === "string" && ["vector", "bm25", "hybrid", "visual"].includes(obj.type);
 }
 function loadManifest(filePath) {
-  const content = readFileSync5(filePath, "utf-8");
-  const ext = extname(filePath).toLowerCase();
+  const content = readFileSync6(filePath, "utf-8");
+  const ext = extname4(filePath).toLowerCase();
   let data;
   if (ext === ".yaml" || ext === ".yml") {
     data = parseYaml(content);
@@ -2386,7 +5021,7 @@ function loadManifest(filePath) {
   };
 }
 function loadManifests(dirPath) {
-  if (!existsSync5(dirPath)) {
+  if (!existsSync6(dirPath)) {
     return [];
   }
   let entries;
@@ -2397,10 +5032,10 @@ function loadManifests(dirPath) {
   }
   const manifests = [];
   for (const entry of entries) {
-    const ext = extname(entry).toLowerCase();
+    const ext = extname4(entry).toLowerCase();
     if (ext !== ".yaml" && ext !== ".yml" && ext !== ".json")
       continue;
-    const filePath = join7(dirPath, entry);
+    const filePath = join10(dirPath, entry);
     try {
       const manifest = loadManifest(filePath);
       manifests.push(manifest);
@@ -2486,7 +5121,7 @@ var init_check_memory_tool = __esm(() => {
 });
 
 // src/retrieval/evidence-id.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function normalizeEvidenceText(text) {
   return text.replace(/\r\n?/gu, `
 `).trim().normalize("NFC");
@@ -2516,7 +5151,7 @@ function stableEvidenceId(input) {
     input.lineNumber ?? "",
     normalizeEvidenceText(evidenceText)
   ].join("\x00");
-  const digest = createHash("sha256").update(payload).digest("hex").slice(0, 24);
+  const digest = createHash3("sha256").update(payload).digest("hex").slice(0, 24);
   return `${method}:${digest}`;
 }
 function normalizeEvidenceRef(input) {
@@ -2528,9 +5163,9 @@ function normalizeEvidenceRef(input) {
 var init_evidence_id = () => {};
 
 // src/memory/memory.ts
-import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
 function emptyMemoryV4() {
   return {
     version: 4,
@@ -2587,7 +5222,7 @@ function normalizeV4(data) {
   };
 }
 function hashText(value) {
-  return createHash2("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function resultId(sessionId, number) {
   return `${sessionId}:${number}`;
@@ -2687,9 +5322,9 @@ class RetrievalMemory {
     this.persistedData = cloneMemory(this.data);
   }
   save() {
-    const dir = dirname3(this.storagePath);
-    if (!existsSync6(dir))
-      mkdirSync3(dir, { recursive: true });
+    const dir = dirname5(this.storagePath);
+    if (!existsSync7(dir))
+      mkdirSync4(dir, { recursive: true });
     const lock = this.acquireLock();
     const localData = this.data;
     let tmpPath;
@@ -2697,7 +5332,7 @@ class RetrievalMemory {
       this.data = this.mergeWithPersisted(this.readPersistedData());
       this.capData();
       tmpPath = `${this.storagePath}.${randomUUID3()}.tmp`;
-      writeFileSync2(tmpPath, `${JSON.stringify(this.data, null, 2)}
+      writeFileSync3(tmpPath, `${JSON.stringify(this.data, null, 2)}
 `, "utf-8");
       lock.assertOwned();
       renameSync2(tmpPath, this.storagePath);
@@ -2707,7 +5342,7 @@ class RetrievalMemory {
       throw error;
     } finally {
       try {
-        if (tmpPath && existsSync6(tmpPath))
+        if (tmpPath && existsSync7(tmpPath))
           unlinkSync3(tmpPath);
       } finally {
         lock.release();
@@ -2911,10 +5546,10 @@ class RetrievalMemory {
     });
   }
   readPersistedData() {
-    if (!existsSync6(this.storagePath))
+    if (!existsSync7(this.storagePath))
       return emptyMemoryV4();
     try {
-      const parsed = JSON.parse(readFileSync6(this.storagePath, "utf-8"));
+      const parsed = JSON.parse(readFileSync7(this.storagePath, "utf-8"));
       if (isV4(parsed))
         return normalizeV4(parsed);
     } catch (error) {
@@ -3165,17 +5800,17 @@ var init_memory = __esm(() => {
 });
 
 // src/minsync/embedder-config.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join8 } from "node:path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join11 } from "node:path";
 import { parse as parse2, stringify } from "smol-toml";
 function minSyncConfigPath(workspacePath) {
-  return join8(workspacePath, MINSYNC_CONFIG_DIR, MINSYNC_CONFIG_FILE);
+  return join11(workspacePath, MINSYNC_CONFIG_DIR, MINSYNC_CONFIG_FILE);
 }
 function rewriteEmbedderConfig(workspacePath, embedder) {
   const configPath = minSyncConfigPath(workspacePath);
   let raw;
   try {
-    raw = readFileSync7(configPath, "utf8");
+    raw = readFileSync8(configPath, "utf8");
   } catch {
     return false;
   }
@@ -3205,17 +5840,17 @@ function rewriteEmbedderConfig(workspacePath, embedder) {
   }
   if (embedder.dimension !== undefined)
     options.dimension = embedder.dimension;
-  writeFileSync3(configPath, stringify(parsed));
+  writeFileSync4(configPath, stringify(parsed));
   return true;
 }
 var MINSYNC_CONFIG_DIR = ".minsync", MINSYNC_CONFIG_FILE = "config.toml";
 var init_embedder_config = () => {};
 
 // src/minsync/process.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 function spawnProcess(command, args, cwd, options = {}) {
   return new Promise((resolve6) => {
-    const child = spawn3(command, [...args], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn6(command, [...args], { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     let timedOut = false;
@@ -3250,7 +5885,7 @@ function spawnProcess(command, args, cwd, options = {}) {
 var init_process = () => {};
 
 // src/minsync/client.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 
 class MinSyncClient {
   binaryPath;
@@ -3262,7 +5897,7 @@ class MinSyncClient {
     this.embedder = options.embedder;
   }
   async sync() {
-    if (!existsSync7(this.binaryPath)) {
+    if (!existsSync8(this.binaryPath)) {
       return { ok: false, synced: 0, workspacePath: this.workspacePath, reason: "missing-binary" };
     }
     if (this.embedder?.apiKeyEnv) {
@@ -3309,7 +5944,7 @@ class MinSyncClient {
     return { ok: true, synced: readSyncedCount(result.stdout), workspacePath: this.workspacePath };
   }
   async query(text, topK) {
-    if (!existsSync7(this.binaryPath))
+    if (!existsSync8(this.binaryPath))
       return [];
     const result = await spawnProcess(this.binaryPath, ["query", "--format", "json", "-k", String(topK), text], this.workspacePath);
     if (!result.ok)
@@ -3364,23 +5999,23 @@ var init_client2 = __esm(() => {
 });
 
 // src/minsync/installer.ts
-import { createHash as createHash3 } from "node:crypto";
-import { createWriteStream, existsSync as existsSync8, mkdirSync as mkdirSync4, renameSync as renameSync3, rmSync } from "node:fs";
+import { createHash as createHash5 } from "node:crypto";
+import { createWriteStream, existsSync as existsSync9, mkdirSync as mkdirSync5, renameSync as renameSync3, rmSync } from "node:fs";
 import { chmod, mkdtemp } from "node:fs/promises";
 import { get } from "node:https";
 import { tmpdir } from "node:os";
-import { basename as basename3, dirname as dirname4, join as join9 } from "node:path";
+import { basename as basename6, dirname as dirname6, join as join12 } from "node:path";
 import { pipeline } from "node:stream/promises";
 async function ensureMinSyncBinary(options) {
-  const binaryPath = join9(options.root, ".autorag", "bin", executableName(options.platform ?? process.platform));
-  if (existsSync8(binaryPath))
+  const binaryPath = join12(options.root, ".autorag", "bin", executableName(options.platform ?? process.platform));
+  if (existsSync9(binaryPath))
     return { binaryPath, version: "cached" };
   const releaseProvider = options.releaseProvider ?? fetchLatestMinSyncRelease;
   const release = await releaseProvider();
   const asset = selectReleaseAsset(release, options.platform ?? process.platform, options.arch ?? process.arch);
   requireSha256(asset);
   const assetInstaller = options.assetInstaller ?? installReleaseAsset;
-  mkdirSync4(dirname4(binaryPath), { recursive: true });
+  mkdirSync5(dirname6(binaryPath), { recursive: true });
   await assetInstaller(asset, binaryPath);
   await chmod(binaryPath, 493);
   return { binaryPath, version: release.tagName };
@@ -3409,9 +6044,9 @@ function selectReleaseAsset(release, platform, arch) {
 }
 async function installReleaseAsset(asset, destination) {
   const expectedSha256 = requireSha256(asset);
-  const tempDir = await mkdtemp(join9(tmpdir(), "autorag-minsync-install-"));
+  const tempDir = await mkdtemp(join12(tmpdir(), "autorag-minsync-install-"));
   try {
-    const archive = join9(tempDir, asset.name);
+    const archive = join12(tempDir, asset.name);
     await downloadFile(asset.downloadUrl, archive);
     await verifySha256(archive, expectedSha256);
     if (!asset.name.endsWith(".tar.gz") && !asset.name.endsWith(".zip")) {
@@ -3420,7 +6055,7 @@ async function installReleaseAsset(asset, destination) {
     const extracted = await spawnProcess("tar", ["-xf", archive, "-C", tempDir], tempDir);
     if (!extracted.ok)
       throw new MinSyncReleaseError(extracted.stderr || `Could not extract ${asset.name}`);
-    renameSync3(join9(tempDir, basename3(destination)), destination);
+    renameSync3(join12(tempDir, basename6(destination)), destination);
   } finally {
     rmSync(tempDir, { recursive: true, force: true });
   }
@@ -3429,7 +6064,7 @@ async function downloadFile(url, destination) {
   await pipeline(await openHttps(url), createWriteStream(destination));
 }
 async function verifySha256(path, expected) {
-  const hash = createHash3("sha256");
+  const hash = createHash5("sha256");
   const stream = await import("node:fs").then((fs) => fs.createReadStream(path));
   await pipeline(stream, hash);
   const actual = hash.digest("hex");
@@ -3531,56 +6166,56 @@ var init_installer2 = __esm(() => {
 });
 
 // src/minsync/paths.ts
-import { join as join10 } from "node:path";
+import { join as join13 } from "node:path";
 function minSyncWorkspaceRoot(root) {
-  return join10(root, MINSYNC_SUBDIR);
+  return join13(root, MINSYNC_SUBDIR);
 }
 function minSyncDocumentPath(workspacePath, virtualPath) {
   const safePath = virtualPath.replace(/^\/+/, "");
-  return join10(workspacePath, MINSYNC_FILES_SUBDIR, `${safePath}.md`);
+  return join13(workspacePath, MINSYNC_FILES_SUBDIR, `${safePath}.md`);
 }
 var MINSYNC_SUBDIR, MINSYNC_FILES_SUBDIR = "files";
 var init_paths = __esm(() => {
-  MINSYNC_SUBDIR = join10(".autorag", "minsync");
+  MINSYNC_SUBDIR = join13(".autorag", "minsync");
 });
 
 // src/mirror/paths.ts
-import { createHash as createHash4 } from "node:crypto";
-import { join as join11 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { join as join14 } from "node:path";
 function parsedMirrorRoot(root) {
-  return join11(root, PARSED_MIRROR_SUBDIR);
+  return join14(root, PARSED_MIRROR_SUBDIR);
 }
 function parsedMirrorIndexPath(root) {
-  return join11(parsedMirrorRoot(root), PARSED_INDEX_FILE);
+  return join14(parsedMirrorRoot(root), PARSED_INDEX_FILE);
 }
 function parsedOutputPath(root, virtualPath) {
-  const digest = createHash4("sha256").update(virtualPath).digest("hex");
-  return join11(parsedMirrorRoot(root), PARSED_FILES_SUBDIR, `${digest}.md`);
+  const digest = createHash6("sha256").update(virtualPath).digest("hex");
+  return join14(parsedMirrorRoot(root), PARSED_FILES_SUBDIR, `${digest}.md`);
 }
 var PARSED_MIRROR_SUBDIR, PARSED_FILES_SUBDIR = "files", PARSED_INDEX_FILE = "index.json";
 var init_paths2 = __esm(() => {
-  PARSED_MIRROR_SUBDIR = join11(".autorag", "parsed");
+  PARSED_MIRROR_SUBDIR = join14(".autorag", "parsed");
 });
 
 // src/mirror/index-store.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync9, renameSync as renameSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname7 } from "node:path";
 function emptyMirrorIndex() {
   return { version: 1, entries: {} };
 }
 function loadMirrorIndex(root) {
   const path = parsedMirrorIndexPath(root);
-  if (!existsSync9(path))
+  if (!existsSync10(path))
     return emptyMirrorIndex();
-  const parsed = JSON.parse(readFileSync8(path, "utf8"));
+  const parsed = JSON.parse(readFileSync9(path, "utf8"));
   return isParsedMirrorIndex(parsed) ? parsed : emptyMirrorIndex();
 }
 function saveMirrorIndex(root, index) {
   const path = parsedMirrorIndexPath(root);
-  mkdirSync5(dirname5(path), { recursive: true });
+  mkdirSync6(dirname7(path), { recursive: true });
   const tmp = `${path}.${randomUUID4()}.tmp`;
-  writeFileSync4(tmp, `${JSON.stringify(index, null, 2)}
+  writeFileSync5(tmp, `${JSON.stringify(index, null, 2)}
 `);
   renameSync4(tmp, path);
 }
@@ -3600,17 +6235,17 @@ var init_index_store = __esm(() => {
 });
 
 // src/minsync/workspace.ts
-import { copyFileSync, existsSync as existsSync10, mkdirSync as mkdirSync6, rmSync as rmSync2 } from "node:fs";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { copyFileSync, existsSync as existsSync11, mkdirSync as mkdirSync7, rmSync as rmSync2 } from "node:fs";
+import { dirname as dirname8, join as join15 } from "node:path";
 function syncMinSyncWorkspace(root, options = {}) {
   const workspacePath = options.workspacePath ?? minSyncWorkspaceRoot(root);
-  const filesRoot = join12(workspacePath, "files");
+  const filesRoot = join15(workspacePath, "files");
   rmSync2(filesRoot, { recursive: true, force: true });
-  mkdirSync6(filesRoot, { recursive: true });
+  mkdirSync7(filesRoot, { recursive: true });
   const index = loadMirrorIndex(root);
-  const entries = Object.values(index.entries).sort((a, b) => a.virtualPath.localeCompare(b.virtualPath)).filter((entry) => existsSync10(entry.outputPath)).map((entry) => {
+  const entries = Object.values(index.entries).sort((a, b) => a.virtualPath.localeCompare(b.virtualPath)).filter((entry) => existsSync11(entry.outputPath)).map((entry) => {
     const minSyncPath = minSyncDocumentPath(workspacePath, entry.virtualPath);
-    mkdirSync6(dirname6(minSyncPath), { recursive: true });
+    mkdirSync7(dirname8(minSyncPath), { recursive: true });
     copyFileSync(entry.outputPath, minSyncPath);
     return {
       virtualPath: entry.virtualPath,
@@ -3640,7 +6275,7 @@ function buildMinSyncPathMap(root, workspacePath) {
   return byPath;
 }
 function legacyParsedVirtualPath(root, virtualPath) {
-  return join12(root, ".autorag", "parsed", "files", `${virtualPath.replace(/^\/+/, "")}.md`);
+  return join15(root, ".autorag", "parsed", "files", `${virtualPath.replace(/^\/+/, "")}.md`);
 }
 var init_workspace = __esm(() => {
   init_index_store();
@@ -3648,8 +6283,8 @@ var init_workspace = __esm(() => {
 });
 
 // src/minsync/method.ts
-import { accessSync, constants, existsSync as existsSync11 } from "node:fs";
-import { basename as basename4, delimiter as delimiter2, join as join13 } from "node:path";
+import { accessSync, constants, existsSync as existsSync12 } from "node:fs";
+import { basename as basename7, delimiter as delimiter2, join as join16 } from "node:path";
 function degrade(workspacePath, reason) {
   return { ok: false, synced: 0, workspacePath, reason };
 }
@@ -3661,7 +6296,7 @@ function lookupInPath(env) {
   for (const dir of pathEnv.split(delimiter2)) {
     if (dir.length === 0)
       continue;
-    const candidate = join13(dir, execName);
+    const candidate = join16(dir, execName);
     try {
       accessSync(candidate, constants.X_OK);
       return candidate;
@@ -3711,7 +6346,7 @@ class MinSyncVectorMethod {
     return binaryResult;
   }
   isBinaryMissing() {
-    return this.binaryPath !== undefined && !existsSync11(this.binaryPath);
+    return this.binaryPath !== undefined && !existsSync12(this.binaryPath);
   }
   async retrieve(query, options) {
     const topK = options.topK ?? 20;
@@ -3732,7 +6367,7 @@ class MinSyncVectorMethod {
       if (!entry || !matchesVirtualPathScope(entry.virtualPath, options.scope))
         continue;
       results.push({
-        id: `minsync:${entry.virtualPath}:${basename4(hit.path)}`,
+        id: `minsync:${entry.virtualPath}:${basename7(hit.path)}`,
         content: hit.text,
         source: entry.virtualPath,
         score: hit.score,
@@ -3744,14 +6379,14 @@ class MinSyncVectorMethod {
     return results;
   }
   async resolveBinary() {
-    if (this.binaryPath && existsSync11(this.binaryPath)) {
+    if (this.binaryPath && existsSync12(this.binaryPath)) {
       return this.binaryPath;
     }
     const pathBinary = lookupInPath(process.env);
     if (pathBinary)
       return pathBinary;
-    const cachedBinary = join13(this.root, ".autorag", "bin", executableName(process.platform));
-    if (existsSync11(cachedBinary))
+    const cachedBinary = join16(this.root, ".autorag", "bin", executableName(process.platform));
+    if (existsSync12(cachedBinary))
       return cachedBinary;
     if (this.autoInstall) {
       try {
@@ -3835,7 +6470,7 @@ class Parser {
 }
 
 // src/parser/eml.ts
-import { simpleParser } from "mailparser";
+import { simpleParser as simpleParser2 } from "mailparser";
 function addressText(address) {
   if (address === undefined)
     return;
@@ -3853,7 +6488,7 @@ var init_eml = __esm(() => {
     extensions = [".eml"];
     async parse(input) {
       try {
-        const parsed = await simpleParser(Buffer.from(input.bytes));
+        const parsed = await simpleParser2(Buffer.from(input.bytes));
         const from = addressText(parsed.from);
         const to = addressText(parsed.to);
         const lines = [
@@ -3882,9 +6517,480 @@ var init_eml = __esm(() => {
   };
 });
 
+// src/parser/hwp-markdown.ts
+function renderHwpMarkdown(document) {
+  const tables = new Map;
+  for (const table of document.tables) {
+    const key = `${table.sectionIndex}:${table.parentParagraphIndex}`;
+    const group = tables.get(key) ?? [];
+    group.push(table);
+    tables.set(key, group);
+  }
+  for (const group of tables.values()) {
+    group.sort((left, right) => left.controlIndex - right.controlIndex);
+  }
+  const blocks = [];
+  for (const paragraph of document.paragraphs) {
+    const text = cleanText(paragraph.text);
+    if (hasRenderableText(text))
+      blocks.push(text);
+    for (const table of tables.get(`${paragraph.sectionIndex}:${paragraph.paragraphIndex}`) ?? []) {
+      const rendered = renderTable(table);
+      if (rendered.length > 0)
+        blocks.push(rendered);
+    }
+  }
+  return blocks.join(`
+
+`);
+}
+function cleanText(text) {
+  return text.replace(/[\u0000\uFFFC]/gu, "");
+}
+function hasRenderableText(text) {
+  return text.trim().length > 0;
+}
+function renderTable(table) {
+  const cells = table.cells.map((cell) => ({ ...cell, text: renderCell(cell) }));
+  if (!cells.some((cell) => hasRenderableText(cell.text)))
+    return "";
+  if (cells.some((cell) => cell.rowSpan > 1 || cell.columnSpan > 1))
+    return renderMergedTable(cells);
+  const cellsByPosition = new Map(cells.map((cell) => [`${cell.row}:${cell.column}`, cell.text]));
+  const header = Array.from({ length: table.columnCount }, (_, column) => `Column ${column + 1}`);
+  const rows = Array.from({ length: table.rowCount }, (_, row) => Array.from({ length: table.columnCount }, (_2, column) => cellsByPosition.get(`${row}:${column}`) ?? ""));
+  return [
+    `| ${header.join(" | ")} |`,
+    `| ${header.map(() => "---").join(" | ")} |`,
+    ...rows.map((row) => `| ${row.join(" | ")} |`)
+  ].join(`
+`);
+}
+function renderMergedTable(cells) {
+  const rows = new Map;
+  const coveredPositions = new Set;
+  for (const cell of [...cells].sort((left, right) => left.row - right.row || left.column - right.column)) {
+    const position = `${cell.row}:${cell.column}`;
+    if (coveredPositions.has(position))
+      continue;
+    const row = rows.get(cell.row) ?? [];
+    row.push(cell);
+    rows.set(cell.row, row);
+    for (let rowIndex = cell.row;rowIndex < cell.row + Math.max(1, cell.rowSpan); rowIndex += 1) {
+      for (let columnIndex = cell.column;columnIndex < cell.column + Math.max(1, cell.columnSpan); columnIndex += 1) {
+        if (rowIndex !== cell.row || columnIndex !== cell.column)
+          coveredPositions.add(`${rowIndex}:${columnIndex}`);
+      }
+    }
+  }
+  const renderedRows = [...rows.entries()].sort(([left], [right]) => left - right).map(([row, cellsInRow]) => {
+    const text = cellsInRow.sort((left, right) => left.column - right.column).map((cell) => cell.text).filter(hasRenderableText).join(" | ");
+    return hasRenderableText(text) ? `Row ${row + 1}: ${text}` : "";
+  }).filter((row) => row.length > 0);
+  return ["[Table]", ...renderedRows].join(`
+`);
+}
+function renderCell(cell) {
+  return cell.paragraphs.map(cleanText).filter(hasRenderableText).join("<br>").replaceAll("\\", "\\\\").replace(/\r\n|\r|\n/gu, "<br>").replaceAll("|", "\\|");
+}
+
+// src/parser/rhwp-adapter.ts
+import { readFile 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();
+    }
+  };
+}
+function createRuntimeInitializer(runtime) {
+  let initialization;
+  return () => {
+    if (initialization === undefined) {
+      const attempt = runtime.initialize();
+      initialization = attempt.catch((error) => {
+        initialization = undefined;
+        throw error;
+      });
+    }
+    return initialization;
+  };
+}
+function extractDocument(document, limits) {
+  const paragraphs = [];
+  const paragraphCounts = [];
+  const counters = { characters: 0, tables: 0, cells: 0, cellParagraphs: 0 };
+  const sectionCount = readCount(document.getSectionCount(), "section count");
+  checkBudget("maxSections", sectionCount, limits);
+  for (let sectionIndex = 0;sectionIndex < sectionCount; sectionIndex += 1) {
+    const paragraphCount = readCount(document.getParagraphCount(sectionIndex), `paragraph count for section ${sectionIndex}`);
+    paragraphCounts.push(paragraphCount);
+    checkBudget("maxBodyParagraphs", paragraphs.length + paragraphCount, limits);
+    for (let paragraphIndex = 0;paragraphIndex < paragraphCount; paragraphIndex += 1) {
+      const length = readCount(document.getParagraphLength(sectionIndex, paragraphIndex), `paragraph length at ${sectionIndex}:${paragraphIndex}`);
+      const text = readText(document.getTextRange(sectionIndex, paragraphIndex, 0, length), `paragraph text at ${sectionIndex}:${paragraphIndex}`);
+      counters.characters += [...text].length;
+      checkBudget("maxCharacters", counters.characters, limits);
+      paragraphs.push({
+        sectionIndex,
+        paragraphIndex,
+        text
+      });
+    }
+  }
+  return { paragraphs, tables: extractTables(document, limits, counters, paragraphCounts) };
+}
+function extractTables(document, limits, counters, paragraphCounts) {
+  const tables = [];
+  const seen = new Set;
+  const pageCount = readCount(document.pageCount(), "page count");
+  for (let pageIndex = 0;pageIndex < pageCount; pageIndex += 1) {
+    const layout = readJsonRecord(document.getPageControlLayout(pageIndex), `page ${pageIndex} control layout`);
+    const controls = readArray(layout.controls, `controls for page ${pageIndex}`);
+    for (let layoutIndex = 0;layoutIndex < controls.length; layoutIndex += 1) {
+      const control = readRecord(controls[layoutIndex], `control ${layoutIndex} on page ${pageIndex}`);
+      if (typeof control.type !== "string") {
+        throw new TypeError(`rhwp returned an invalid control type at page ${pageIndex}:${layoutIndex}`);
+      }
+      if (control.type !== "table")
+        continue;
+      const label = `table at page ${pageIndex}:${layoutIndex}`;
+      const coordinates = readTableCoordinates(control, label, paragraphCounts, limits);
+      if (coordinates === undefined)
+        continue;
+      const key = `${coordinates.sectionIndex}:${coordinates.parentParagraphIndex}:${coordinates.controlIndex}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      counters.tables += 1;
+      checkBudget("maxTables", counters.tables, limits);
+      tables.push(extractTable(document, coordinates, limits, counters));
+    }
+  }
+  return tables;
+}
+function readTableCoordinates(control, label, paragraphCounts, limits) {
+  const hasSectionIndex = Object.hasOwn(control, "secIdx");
+  const hasParagraphIndex = Object.hasOwn(control, "paraIdx");
+  const hasControlIndex = Object.hasOwn(control, "controlIdx");
+  const coordinateCount = Number(hasSectionIndex) + Number(hasParagraphIndex) + Number(hasControlIndex);
+  if (coordinateCount === 0) {
+    validateDeferredNestedTable(control, label, limits);
+    return;
+  }
+  if (coordinateCount !== 3) {
+    throw new TypeError(`rhwp returned a partial coordinate set for ${label}`);
+  }
+  if (Object.hasOwn(control, "cellPath") || Object.hasOwn(control, "parentParaIdx")) {
+    throw new TypeError(`rhwp returned conflicting top-level and nested context for ${label}`);
+  }
+  const coordinates = {
+    sectionIndex: readCount(control.secIdx, `secIdx for ${label}`),
+    parentParagraphIndex: readCount(control.paraIdx, `paraIdx for ${label}`),
+    controlIndex: readCount(control.controlIdx, `controlIdx for ${label}`)
+  };
+  const paragraphCount = paragraphCounts[coordinates.sectionIndex];
+  if (paragraphCount === undefined) {
+    throw new TypeError(`rhwp returned a section coordinate outside the announced document range for ${label}`);
+  }
+  if (coordinates.parentParagraphIndex >= paragraphCount) {
+    throw new TypeError(`rhwp returned a parent paragraph coordinate outside the announced section range for ${label}`);
+  }
+  return coordinates;
+}
+function validateDeferredNestedTable(control, label, limits) {
+  if (!Object.hasOwn(control, "cellPath") && !Object.hasOwn(control, "parentParaIdx")) {
+    validateDeferredNestedLayout(control, label, limits);
+    return;
+  }
+  readCount(control.parentParaIdx, `parentParaIdx for deferred nested ${label}`);
+  const cellPath = readArray(control.cellPath, `cellPath for deferred nested ${label}`);
+  if (cellPath.length === 0) {
+    throw new TypeError(`rhwp returned an empty cellPath for deferred nested ${label}`);
+  }
+  checkBudget("maxCells", cellPath.length, limits);
+  for (let pathIndex = 0;pathIndex < cellPath.length; pathIndex += 1) {
+    const entry = readRecord(cellPath[pathIndex], `cellPath entry ${pathIndex} for deferred nested ${label}`);
+    readCount(entry.controlIndex, `controlIndex in cellPath entry ${pathIndex} for deferred nested ${label}`);
+    readCount(entry.cellIndex, `cellIndex in cellPath entry ${pathIndex} for deferred nested ${label}`);
+    readCount(entry.cellParaIndex, `cellParaIndex in cellPath entry ${pathIndex} for deferred nested ${label}`);
+  }
+}
+function validateDeferredNestedLayout(control, label, limits) {
+  readFiniteNumber(control.x, `x for deferred nested ${label}`);
+  readFiniteNumber(control.y, `y for deferred nested ${label}`);
+  readPositiveFiniteNumber(control.w, `w for deferred nested ${label}`);
+  readPositiveFiniteNumber(control.h, `h for deferred nested ${label}`);
+  const rowCount = readPositiveCount(control.rowCount, `rowCount for deferred nested ${label}`);
+  const columnCount = readPositiveCount(control.colCount, `colCount for deferred nested ${label}`);
+  const logicalCellCount = readLogicalCellCount(rowCount, columnCount, limits);
+  readCount(control.plane, `plane for deferred nested ${label}`);
+  readSafeInteger(control.zOrder, `zOrder for deferred nested ${label}`);
+  readCount(control.stableIndex, `stableIndex for deferred nested ${label}`);
+  const cells = readArray(control.cells, `cells for deferred nested ${label}`);
+  if (cells.length === 0) {
+    throw new TypeError(`rhwp returned empty cells for deferred nested ${label}`);
+  }
+  checkBudget("maxCells", cells.length, limits);
+  if (cells.length > logicalCellCount) {
+    throw new TypeError(`rhwp returned too many cells for deferred nested ${label}`);
+  }
+  const anchors = new Set;
+  const cellIndexes = new Set;
+  const coveredCoordinates = new Set;
+  for (let cellIndex = 0;cellIndex < cells.length; cellIndex += 1) {
+    const cell = readRecord(cells[cellIndex], `cell ${cellIndex} for deferred nested ${label}`);
+    readFiniteNumber(cell.x, `x for cell ${cellIndex} in deferred nested ${label}`);
+    readFiniteNumber(cell.y, `y for cell ${cellIndex} in deferred nested ${label}`);
+    readPositiveFiniteNumber(cell.w, `w for cell ${cellIndex} in deferred nested ${label}`);
+    readPositiveFiniteNumber(cell.h, `h for cell ${cellIndex} in deferred nested ${label}`);
+    const row = readCount(cell.row, `row for cell ${cellIndex} in deferred nested ${label}`);
+    const column = readCount(cell.col, `col for cell ${cellIndex} in deferred nested ${label}`);
+    const rowSpan = readPositiveCount(cell.rowSpan, `rowSpan for cell ${cellIndex} in deferred nested ${label}`);
+    const columnSpan = readPositiveCount(cell.colSpan, `colSpan for cell ${cellIndex} in deferred nested ${label}`);
+    const runtimeCellIndex = readCount(cell.cellIdx, `cellIdx for cell ${cellIndex} in deferred nested ${label}`);
+    if (row >= rowCount || rowSpan > rowCount - row) {
+      throw new TypeError(`rhwp returned an out-of-range row span for cell ${cellIndex} in deferred nested ${label}`);
+    }
+    if (column >= columnCount || columnSpan > columnCount - column) {
+      throw new TypeError(`rhwp returned an out-of-range col span for cell ${cellIndex} in deferred nested ${label}`);
+    }
+    if (cellIndexes.has(runtimeCellIndex)) {
+      throw new TypeError(`rhwp returned a duplicate cellIdx for deferred nested ${label}`);
+    }
+    cellIndexes.add(runtimeCellIndex);
+    const anchor = `${row}:${column}`;
+    if (anchors.has(anchor)) {
+      throw new TypeError(`rhwp returned a duplicate cell anchor for deferred nested ${label}`);
+    }
+    anchors.add(anchor);
+    for (let coveredRow = row;coveredRow < row + rowSpan; coveredRow += 1) {
+      for (let coveredColumn = column;coveredColumn < column + columnSpan; coveredColumn += 1) {
+        const coordinate = `${coveredRow}:${coveredColumn}`;
+        if (coveredCoordinates.has(coordinate)) {
+          throw new TypeError(`rhwp returned overlapping cell spans for deferred nested ${label}`);
+        }
+        coveredCoordinates.add(coordinate);
+      }
+    }
+  }
+}
+function extractTable(document, coordinates, limits, counters) {
+  const { sectionIndex, parentParagraphIndex, controlIndex } = coordinates;
+  const key = `${sectionIndex}:${parentParagraphIndex}:${controlIndex}`;
+  const dimensions = readJsonRecord(document.getTableDimensions(sectionIndex, parentParagraphIndex, controlIndex), `table dimensions at ${key}`);
+  const rowCount = readPositiveCount(dimensions.rowCount, `rowCount for table ${key}`);
+  const columnCount = readPositiveCount(dimensions.colCount, `colCount for table ${key}`);
+  const cellCount = readCount(dimensions.cellCount, `cellCount for table ${key}`);
+  const logicalCellCount = chargeLogicalCells(rowCount, columnCount, counters, limits);
+  if (cellCount === 0 || cellCount > logicalCellCount) {
+    throw new TypeError(`rhwp returned an invalid cellCount for table ${key}; expected 1..${logicalCellCount}, received ${cellCount}`);
+  }
+  const cellGeometry = [];
+  const anchors = new Set;
+  const coveredCoordinates = new Set;
+  for (let cellIndex = 0;cellIndex < cellCount; cellIndex += 1) {
+    const cellInfo = readJsonRecord(document.getCellInfo(sectionIndex, parentParagraphIndex, controlIndex, cellIndex), `cell metadata at ${key}:${cellIndex}`);
+    const row = readCount(cellInfo.row, `row for cell ${key}:${cellIndex}`);
+    const column = readCount(cellInfo.col, `col for cell ${key}:${cellIndex}`);
+    const rowSpan = readPositiveCount(cellInfo.rowSpan, `rowSpan for cell ${key}:${cellIndex}`);
+    const columnSpan = readPositiveCount(cellInfo.colSpan, `colSpan for cell ${key}:${cellIndex}`);
+    if (row >= rowCount) {
+      throw new TypeError(`rhwp returned a row outside the table range for cell ${key}:${cellIndex}`);
+    }
+    if (column >= columnCount) {
+      throw new TypeError(`rhwp returned a col outside the table range for cell ${key}:${cellIndex}`);
+    }
+    if (rowSpan > rowCount - row) {
+      throw new TypeError(`rhwp returned a rowSpan outside the table range for cell ${key}:${cellIndex}`);
+    }
+    if (columnSpan > columnCount - column) {
+      throw new TypeError(`rhwp returned a colSpan outside the table range for cell ${key}:${cellIndex}`);
+    }
+    const anchor = row * columnCount + column;
+    if (anchors.has(anchor)) {
+      throw new TypeError(`rhwp returned a duplicate cell anchor for table ${key} at ${row}:${column}`);
+    }
+    anchors.add(anchor);
+    for (let coveredRow = row;coveredRow < row + rowSpan; coveredRow += 1) {
+      for (let coveredColumn = column;coveredColumn < column + columnSpan; coveredColumn += 1) {
+        const coordinate = coveredRow * columnCount + coveredColumn;
+        if (coveredCoordinates.has(coordinate)) {
+          throw new TypeError(`rhwp returned overlapping cell spans for table ${key} at ${coveredRow}:${coveredColumn}`);
+        }
+        coveredCoordinates.add(coordinate);
+      }
+    }
+    cellGeometry.push({ row, column, rowSpan, columnSpan });
+  }
+  if (coveredCoordinates.size !== logicalCellCount) {
+    throw new TypeError(`rhwp returned cellCount ${cellCount} that covers ${coveredCoordinates.size} of ${logicalCellCount} logical grid coordinates for table ${key}`);
+  }
+  const cells = [];
+  for (let cellIndex = 0;cellIndex < cellGeometry.length; cellIndex += 1) {
+    const geometry = cellGeometry[cellIndex];
+    if (geometry === undefined)
+      throw new TypeError(`rhwp omitted cell geometry at ${key}:${cellIndex}`);
+    const paragraphCount = readCount(document.getCellParagraphCount(sectionIndex, parentParagraphIndex, controlIndex, cellIndex), `cell paragraph count at ${key}:${cellIndex}`);
+    counters.cellParagraphs += paragraphCount;
+    checkBudget("maxCellParagraphs", counters.cellParagraphs, limits);
+    const paragraphs = [];
+    for (let cellParagraphIndex = 0;cellParagraphIndex < paragraphCount; cellParagraphIndex += 1) {
+      const length = readCount(document.getCellParagraphLength(sectionIndex, parentParagraphIndex, controlIndex, cellIndex, cellParagraphIndex), `cell paragraph length at ${key}:${cellIndex}:${cellParagraphIndex}`);
+      const text = readText(document.getTextInCell(sectionIndex, parentParagraphIndex, controlIndex, cellIndex, cellParagraphIndex, 0, length), `cell paragraph text at ${key}:${cellIndex}:${cellParagraphIndex}`);
+      counters.characters += [...text].length;
+      checkBudget("maxCharacters", counters.characters, limits);
+      paragraphs.push(text);
+    }
+    cells.push({
+      ...geometry,
+      paragraphs
+    });
+  }
+  return {
+    sectionIndex,
+    parentParagraphIndex,
+    controlIndex,
+    rowCount,
+    columnCount,
+    cells
+  };
+}
+function chargeLogicalCells(rowCount, columnCount, counters, limits) {
+  const logicalCellCount = readLogicalCellCount(rowCount, columnCount, limits);
+  if (logicalCellCount > limits.maxCells - counters.cells) {
+    throw new HwpExtractionBudgetError("maxCells", counters.cells + logicalCellCount, limits.maxCells);
+  }
+  counters.cells += logicalCellCount;
+  return logicalCellCount;
+}
+function readLogicalCellCount(rowCount, columnCount, limits) {
+  if (rowCount > Math.floor(limits.maxCells / columnCount)) {
+    throw new HwpExtractionBudgetError("maxCells", rowCount * columnCount, limits.maxCells);
+  }
+  return rowCount * columnCount;
+}
+function resolveLimits(overrides) {
+  const limits = { ...DEFAULT_LIMITS };
+  for (const name of Object.keys(DEFAULT_LIMITS)) {
+    const value = overrides[name];
+    if (value === undefined)
+      continue;
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`${name} must be a positive finite safe integer`);
+    }
+    limits[name] = value;
+  }
+  return limits;
+}
+function checkBudget(name, actual, limits) {
+  if (actual > limits[name])
+    throw new HwpExtractionBudgetError(name, actual, limits[name]);
+}
+function readCount(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`rhwp returned an invalid ${label}; expected a non-negative safe integer`);
+  }
+  return value;
+}
+function readPositiveCount(value, label) {
+  const count = readCount(value, label);
+  if (count === 0) {
+    throw new TypeError(`rhwp returned an invalid ${label}; expected a positive safe integer`);
+  }
+  return count;
+}
+function readSafeInteger(value, label) {
+  if (!Number.isSafeInteger(value)) {
+    throw new TypeError(`rhwp returned an invalid ${label}; expected a safe integer`);
+  }
+  return value;
+}
+function readFiniteNumber(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(`rhwp returned an invalid ${label}; expected a finite number`);
+  }
+  return value;
+}
+function readPositiveFiniteNumber(value, label) {
+  const number = readFiniteNumber(value, label);
+  if (number <= 0) {
+    throw new TypeError(`rhwp returned an invalid ${label}; expected a positive finite number`);
+  }
+  return number;
+}
+function readText(value, label) {
+  if (typeof value !== "string")
+    throw new TypeError(`rhwp returned invalid ${label}; expected a string`);
+  return value;
+}
+function readJsonRecord(value, label) {
+  const text = readText(value, label);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (cause) {
+    throw new TypeError(`rhwp returned malformed JSON for ${label}`, { cause });
+  }
+  return readRecord(parsed, label);
+}
+function readRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`rhwp returned invalid ${label}; expected an object`);
+  }
+  return value;
+}
+function readArray(value, label) {
+  if (!Array.isArray(value))
+    throw new TypeError(`rhwp returned invalid ${label}; expected an array`);
+  return value;
+}
+var DEFAULT_LIMITS, HwpExtractionBudgetError, defaultRhwpRuntime, initializeDefaultRhwpRuntime;
+var init_rhwp_adapter = __esm(() => {
+  DEFAULT_LIMITS = {
+    maxSections: 256,
+    maxBodyParagraphs: 200000,
+    maxTables: 20000,
+    maxCells: 500000,
+    maxCellParagraphs: 1e6,
+    maxCharacters: 20000000
+  };
+  HwpExtractionBudgetError = class HwpExtractionBudgetError extends Error {
+    code = "HWP_EXTRACTION_BUDGET_EXCEEDED";
+    limit;
+    actual;
+    maximum;
+    constructor(limit, actual, maximum) {
+      super(`HWP extraction exceeded ${limit} budget of ${maximum} (received ${actual})`);
+      this.name = "HwpExtractionBudgetError";
+      this.limit = limit;
+      this.actual = actual;
+      this.maximum = maximum;
+    }
+  };
+  defaultRhwpRuntime = {
+    async initialize() {
+      const rhwpModuleUrl = import.meta.resolve("@rhwp/core");
+      const wasmBytes = await readFile3(new URL("./rhwp_bg.wasm", rhwpModuleUrl));
+      await initRhwp({ module_or_path: wasmBytes });
+    },
+    open(bytes) {
+      return new HwpDocument(bytes);
+    }
+  };
+  initializeDefaultRhwpRuntime = createRuntimeInitializer(defaultRhwpRuntime);
+});
+
 // src/parser/xml-text.ts
 import { Buffer as Buffer2 } from "node:buffer";
-import { XMLParser } from "fast-xml-parser";
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
 import JSZip from "jszip";
 async function readZipXmlText(bytes, pathPattern) {
   const zip = await JSZip.loadAsync(bytes);
@@ -3974,7 +7080,7 @@ function isRecord6(value) {
 }
 var parser, MAX_XML_FILES = 64, MAX_XML_BYTES = 5000000, MAX_TEXT_CHUNKS = 20000;
 var init_xml_text = __esm(() => {
-  parser = new XMLParser({
+  parser = new XMLParser2({
     ignoreAttributes: false,
     parseTagValue: false,
     processEntities: true,
@@ -3983,19 +7089,29 @@ var init_xml_text = __esm(() => {
 });
 
 // src/parser/hwp.ts
-import { extname as extname2 } from "node:path";
+import { extname as extname5 } from "node:path";
 var HwpParser;
 var init_hwp = __esm(() => {
   init_errors();
+  init_rhwp_adapter();
   init_text();
   init_xml_text();
   HwpParser = class HwpParser extends Parser {
     name = "hwp";
     extensions = [".hwpx", ".hwp"];
+    extractor;
+    constructor(options = {}) {
+      super();
+      this.extractor = options.extractor ?? createRhwpExtractor(undefined, options.limits);
+    }
     async parse(input) {
       try {
-        if (extname2(input.virtualPath).toLowerCase() === ".hwp") {
-          throw new Error("legacy HWP5 binary parsing is not supported by the pure JavaScript parser");
+        if (extname5(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 {
@@ -4119,7 +7235,7 @@ var init_ocr = __esm(() => {
 });
 
 // src/parser/office.ts
-import { extname as extname3 } from "node:path";
+import { extname as extname6 } from "node:path";
 function formatMarkdown(parserName, chunks) {
   const markdown = normalizeMarkdown(chunks.filter((chunk) => chunk.trim().length > 0).join(`
 
@@ -4160,7 +7276,7 @@ var init_office = __esm(() => {
     extensions = [".xlsx", ".xls"];
     async parse(input) {
       try {
-        if (extname3(input.virtualPath).toLowerCase() === ".xls") {
+        if (extname6(input.virtualPath).toLowerCase() === ".xls") {
           throw new Error("legacy XLS binary parsing is not supported by the pure JavaScript parser");
         }
         const sharedStrings = await readZipXmlText(input.bytes, /^xl\/sharedStrings\.xml$/);
@@ -4174,12 +7290,12 @@ var init_office = __esm(() => {
 });
 
 // src/parser/opendataloader-pdf.ts
-import { mkdtemp as mkdtemp2, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdtemp as mkdtemp2, readFile as readFile4, rm, writeFile } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename5, join as join14, parse as parse3 } from "node:path";
+import { basename as basename8, join as join17, parse as parse3 } from "node:path";
 import { convert } from "@opendataloader/pdf";
 function markdownOutputPath(outputDir, inputPath) {
-  return join14(outputDir, `${parse3(inputPath).name}.md`);
+  return join17(outputDir, `${parse3(inputPath).name}.md`);
 }
 var OpendataloaderPdfParser;
 var init_opendataloader_pdf = __esm(() => {
@@ -4196,9 +7312,9 @@ var init_opendataloader_pdf = __esm(() => {
       this.converter = options.converter ?? convert;
     }
     async parse(input) {
-      const tempRoot = await mkdtemp2(join14(tmpdir2(), "autorag-pdf-"));
+      const tempRoot = await mkdtemp2(join17(tmpdir2(), "autorag-pdf-"));
       try {
-        const inputPath = input.sourcePath ?? join14(tempRoot, basename5(input.virtualPath));
+        const inputPath = input.sourcePath ?? join17(tempRoot, basename8(input.virtualPath));
         if (!input.sourcePath) {
           await writeFile(inputPath, input.bytes);
         }
@@ -4217,7 +7333,7 @@ var init_opendataloader_pdf = __esm(() => {
           } : {}
         });
         return {
-          markdown: normalizeMarkdown(await readFile(markdownOutputPath(tempRoot, inputPath), "utf8")),
+          markdown: normalizeMarkdown(await readFile4(markdownOutputPath(tempRoot, inputPath), "utf8")),
           metadata: { parser: this.name }
         };
       } catch (cause) {
@@ -4243,7 +7359,7 @@ var init_plain_text = __esm(() => {
 });
 
 // src/parser/registry.ts
-import { extname as extname4 } from "node:path";
+import { extname as extname7 } from "node:path";
 
 class ParserRegistry {
   parsersByExtension = new Map;
@@ -4262,7 +7378,7 @@ class ParserRegistry {
     }
   }
   getForVirtualPath(virtualPath) {
-    return this.parsersByExtension.get(normalizeExtension(extname4(virtualPath)));
+    return this.parsersByExtension.get(normalizeExtension(extname7(virtualPath)));
   }
   list() {
     return Array.from(new Set(this.parsersByExtension.values()));
@@ -4282,7 +7398,7 @@ function createDefaultParserRegistry(options = {}) {
     new DocxParser,
     new PptxParser,
     new XlsxParser,
-    new HwpParser,
+    new HwpParser(options.hwp),
     new EmlParser
   ];
   if (options.ocr?.enabled)
@@ -4301,9 +7417,9 @@ var init_defaults = __esm(() => {
 
 // src/mirror/sync.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, renameSync as renameSync5, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { opendir, readFile as readFile2, stat } from "node:fs/promises";
-import { dirname as dirname7, extname as extname5, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, 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 dirname9, extname as extname8, resolve as resolve6 } from "node:path";
 async function syncParsedMirrors(options) {
   const registry = options.registry ?? createDefaultParserRegistry(options.parserOptions);
   const maxSourceBytes = options.maxSourceBytes ?? DEFAULT_MAX_SOURCE_BYTES;
@@ -4351,11 +7467,11 @@ async function syncParsedMirrors(options) {
     }
     const previousEntry = previous.entries[entry.virtualPath];
     const outputPath = parsedOutputPath(options.root, entry.virtualPath);
-    const unchanged = !options.force && previousEntry?.sourceMtimeNs === entry.mtimeNs && previousEntry.sourceSizeBytes === entry.sizeBytes && previousEntry.parserName === parser2.name && existsSync12(outputPath);
+    const unchanged = !options.force && previousEntry?.sourceMtimeNs === entry.mtimeNs && previousEntry.sourceSizeBytes === entry.sizeBytes && previousEntry.parserName === parser2.name && existsSync13(outputPath);
     if (!unchanged) {
       let parsed;
       try {
-        const bytes = await readFile2(entry.sourcePath);
+        const bytes = await readFile5(entry.sourcePath);
         parsed = await parser2.parse({ virtualPath: entry.virtualPath, sourcePath: entry.sourcePath, bytes });
       } catch (error) {
         if (!(error instanceof ParseError))
@@ -4475,12 +7591,12 @@ async function collectFiles(sourceRoot, directory, entries, supportedExtensions)
     }
     if (!entry.isFile())
       continue;
-    const extension = normalizeExtension2(extname5(entry.name));
+    const extension = normalizeExtension2(extname8(entry.name));
     if (!supportedExtensions.has(extension))
       continue;
     let fileStat;
     try {
-      fileStat = await stat(sourcePath, { bigint: true });
+      fileStat = await stat4(sourcePath, { bigint: true });
     } catch {
       continue;
     }
@@ -4500,13 +7616,13 @@ function removePrevious(root, index, virtualPath) {
   return 1;
 }
 function writeAtomic(path, content) {
-  mkdirSync7(dirname7(path), { recursive: true });
+  mkdirSync8(dirname9(path), { recursive: true });
   const tmp = `${path}.${randomUUID5()}.tmp`;
-  writeFileSync5(tmp, content);
+  writeFileSync6(tmp, content);
   renameSync5(tmp, path);
 }
 function removeFile(path) {
-  if (existsSync12(path))
+  if (existsSync13(path))
     rmSync3(path, { force: true });
 }
 var DEFAULT_MAX_SOURCE_BYTES, MIRROR_CHECKPOINT_EVERY = 25, SKIP_DIR_NAMES;
@@ -4543,8 +7659,8 @@ var init_sync = __esm(() => {
 });
 
 // src/observability/run-log.ts
-import { appendFileSync, mkdirSync as mkdirSync8 } from "node:fs";
-import { dirname as dirname8 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync9 } from "node:fs";
+import { dirname as dirname10 } from "node:path";
 
 class AutoRAGRunLogger {
   path;
@@ -4553,7 +7669,7 @@ class AutoRAGRunLogger {
   }
   write(event) {
     try {
-      mkdirSync8(dirname8(this.path), { recursive: true });
+      mkdirSync9(dirname10(this.path), { recursive: true });
       appendFileSync(this.path, `${JSON.stringify(event)}
 `, "utf8");
     } catch (error) {}
@@ -4644,9 +7760,9 @@ function methodFailureCode(name) {
 }
 
 // src/retrieval/methods/bm25.ts
-import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync9, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname9, join as join15 } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync10, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname11, join as join18 } from "node:path";
 
 class BM25Method {
   root;
@@ -4657,16 +7773,16 @@ class BM25Method {
   status;
   constructor(options) {
     this.root = options.root;
-    this.indexPath = options.indexPath ?? join15(options.root, BM25_SUBDIR);
+    this.indexPath = options.indexPath ?? join18(options.root, BM25_SUBDIR);
     this.fallback = options.fallback ?? "typescript";
     this.forceEngine = options.forceEngine;
     this.importBinding = options.importBinding ?? (() => import("@pngwasi/node-tantivy-binding"));
     if (options.enabled === false) {
       this.status = { readiness: "disabled", engine: "none", message: "BM25 is disabled" };
     } else {
-      const tantivyDir = join15(this.indexPath, TANTIVY_SUBDIR);
-      const hasTantivy = existsSync13(join15(tantivyDir, "meta.json"));
-      const hasFallback = existsSync13(join15(this.indexPath, FALLBACK_INDEX_FILE));
+      const tantivyDir = join18(this.indexPath, TANTIVY_SUBDIR);
+      const hasTantivy = existsSync14(join18(tantivyDir, "meta.json"));
+      const hasFallback = existsSync14(join18(this.indexPath, FALLBACK_INDEX_FILE));
       if (hasTantivy) {
         this.status = { readiness: "ready", engine: "tantivy" };
       } else if (hasFallback && this.fallback !== "disabled") {
@@ -4732,7 +7848,7 @@ class BM25Method {
     const trimmedQuery = query.trim();
     if (trimmedQuery.length === 0)
       return [];
-    const topK = options.topK ?? DEFAULT_TOP_K;
+    const topK = options.topK ?? DEFAULT_TOP_K2;
     if (this.status.readiness === "disabled" || this.status.readiness === "dependency_unavailable") {
       throw new BM25UnavailableError(this.status.readiness, this.status.message ?? "BM25 is unavailable");
     }
@@ -4759,7 +7875,7 @@ class BM25Method {
     }
     const indexDir = this.tantivyIndexPath();
     rmSync4(indexDir, { recursive: true, force: true });
-    mkdirSync9(indexDir, { recursive: true });
+    mkdirSync10(indexDir, { recursive: true });
     const schema = new binding.SchemaBuilder().addTextField("virtualPath", { stored: true, indexOption: "basic", tokenizerName: "raw" }).addTextField("chunkId", { stored: true, indexOption: "basic", tokenizerName: "raw" }).addTextField("content", { stored: true, indexOption: "position" }).build();
     const index = new binding.Index(schema, indexDir, false);
     const writer = index.writer(30000000, 1);
@@ -4775,7 +7891,7 @@ class BM25Method {
   async retrieveTantivy(queryText, topK, scope) {
     const binding = await this.importBinding();
     const indexDir = this.tantivyIndexPath();
-    if (!existsSync13(indexDir) || !binding.Index.exists(indexDir)) {
+    if (!existsSync14(indexDir) || !binding.Index.exists(indexDir)) {
       this.status = { readiness: "index_missing", engine: "none", message: "Tantivy BM25 index is missing" };
       throw new BM25UnavailableError("index_missing", "Tantivy BM25 index is missing; call refresh() first");
     }
@@ -4820,18 +7936,18 @@ class BM25Method {
   writeFallbackIndex(chunks) {
     const index = { version: 1, chunks };
     const path = this.fallbackIndexPath();
-    mkdirSync9(dirname9(path), { recursive: true });
-    writeFileSync6(path, `${JSON.stringify(index, null, 2)}
+    mkdirSync10(dirname11(path), { recursive: true });
+    writeFileSync7(path, `${JSON.stringify(index, null, 2)}
 `);
   }
   retrieveFallback(query, topK, scope) {
     const index = this.readFallbackIndex();
-    const queryTerms = tokenize(query);
+    const queryTerms = tokenize2(query);
     if (queryTerms.length === 0)
       return [];
     const scopedChunks = index.chunks.filter((chunk) => matchesVirtualPathScope(chunk.virtualPath, scope));
     const documentFrequencies = new Map;
-    const tokenized = scopedChunks.map((chunk) => ({ chunk, terms: tokenize(chunk.content) }));
+    const tokenized = scopedChunks.map((chunk) => ({ chunk, terms: tokenize2(chunk.content) }));
     for (const term of new Set(queryTerms)) {
       documentFrequencies.set(term, tokenized.filter(({ terms }) => terms.includes(term)).length);
     }
@@ -4854,19 +7970,19 @@ class BM25Method {
   }
   readFallbackIndex() {
     const path = this.fallbackIndexPath();
-    if (!existsSync13(path))
+    if (!existsSync14(path))
       throw new BM25UnavailableError("index_missing", "BM25 fallback index is missing");
-    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    const parsed = JSON.parse(readFileSync10(path, "utf8"));
     return parsed.version === 1 && Array.isArray(parsed.chunks) ? parsed : { version: 1, chunks: [] };
   }
   hasFallbackIndex() {
-    return existsSync13(this.fallbackIndexPath());
+    return existsSync14(this.fallbackIndexPath());
   }
   tantivyIndexPath() {
-    return join15(this.indexPath, TANTIVY_SUBDIR);
+    return join18(this.indexPath, TANTIVY_SUBDIR);
   }
   fallbackIndexPath() {
-    return join15(this.indexPath, FALLBACK_INDEX_FILE);
+    return join18(this.indexPath, FALLBACK_INDEX_FILE);
   }
   syncResult(indexedChunks) {
     return {
@@ -4881,9 +7997,9 @@ function loadChunks(root) {
   const index = loadMirrorIndex(root);
   const chunks = [];
   for (const entry of Object.values(index.entries).sort((a, b) => a.virtualPath.localeCompare(b.virtualPath))) {
-    if (!existsSync13(entry.outputPath))
+    if (!existsSync14(entry.outputPath))
       continue;
-    const content = normalizeMarkdown(readFileSync9(entry.outputPath, "utf8"));
+    const content = normalizeMarkdown(readFileSync10(entry.outputPath, "utf8"));
     for (const [chunkIndex, chunkContent] of chunkMarkdown(content).entries()) {
       chunks.push({
         id: `bm25:${entry.virtualPath}:${chunkIndex}:${hash(chunkContent)}`,
@@ -4913,7 +8029,7 @@ ${paragraph}`;
     chunks.push(current);
   return chunks;
 }
-function tokenize(value) {
+function tokenize2(value) {
   return value.toLowerCase().match(/[\p{Letter}\p{Number}_]+/gu) ?? [];
 }
 function bm25Score(queryTerms, documentTerms, documentFrequencies, documentCount, avgDocumentLength) {
@@ -4939,13 +8055,13 @@ function firstString(values) {
   return typeof first === "string" ? first : undefined;
 }
 function hash(value) {
-  return createHash5("sha256").update(value).digest("hex").slice(0, 12);
+  return createHash7("sha256").update(value).digest("hex").slice(0, 12);
 }
-var BM25_SUBDIR, TANTIVY_SUBDIR = "tantivy", FALLBACK_INDEX_FILE = "fallback-index.json", DEFAULT_TOP_K = 20, MAX_CHUNK_CHARS = 2400, BM25UnavailableError;
+var BM25_SUBDIR, TANTIVY_SUBDIR = "tantivy", FALLBACK_INDEX_FILE = "fallback-index.json", DEFAULT_TOP_K2 = 20, MAX_CHUNK_CHARS = 2400, BM25UnavailableError;
 var init_bm25 = __esm(() => {
   init_index_store();
   init_text();
-  BM25_SUBDIR = join15(".autorag", "bm25");
+  BM25_SUBDIR = join18(".autorag", "bm25");
   BM25UnavailableError = class BM25UnavailableError extends Error {
     readiness;
     constructor(readiness, message) {
@@ -4979,7 +8095,7 @@ class RetrievalMethodRegistry {
 
 // src/subagents/contracts.ts
 function parseExplorerAssignment(value) {
-  const record = asRecord(value, "explorer assignment");
+  const record = asRecord2(value, "explorer assignment");
   const originalQuery = requiredText(record, "originalQuery", "MISSING_ORIGINAL_QUERY", "INVALID_ORIGINAL_QUERY");
   const method = requiredMethod(record, "method", "MISSING_RETRIEVAL_METHOD", "INVALID_RETRIEVAL_METHOD");
   const queryVariant = requiredText(record, "queryVariant", "MISSING_QUERY_VARIANT", "INVALID_QUERY_VARIANT");
@@ -4995,7 +8111,7 @@ function parseExplorerAssignment(value) {
   return { originalQuery, method, queryVariant, queryVariants: [...variantsRaw] };
 }
 function parseEvidenceCandidate(value) {
-  const record = asRecord(value, "evidence candidate");
+  const record = asRecord2(value, "evidence candidate");
   const source = requiredText(record, "source", "MISSING_SOURCE", "INVALID_SOURCE");
   const method = requiredMethod(record, "method", "MISSING_EVIDENCE_METHOD", "INVALID_EVIDENCE_METHOD");
   const evidence = requiredText(record, "evidence", "MISSING_EVIDENCE", "INVALID_EVIDENCE");
@@ -5019,7 +8135,7 @@ function parseEvidenceCandidate(value) {
   };
 }
 function parseExplorerReport(value) {
-  const record = asRecord(value, "explorer report");
+  const record = asRecord2(value, "explorer report");
   const assignmentRaw = record.assignment;
   if (assignmentRaw === undefined) {
     throw new ContractValidationError("MISSING_ASSIGNMENT", "assignment is required.", "assignment");
@@ -5048,7 +8164,7 @@ function safeParseExplorerReport(value) {
   return safeParse(() => parseExplorerReport(value));
 }
 function parseSourceTemporal(value) {
-  const record = asRecord(value, "sourceTemporal");
+  const record = asRecord2(value, "sourceTemporal");
   const status = record.status;
   if (status === undefined) {
     throw new ContractValidationError("INVALID_SOURCE_TEMPORAL", "sourceTemporal.status is required.", "sourceTemporal.status");
@@ -5068,7 +8184,7 @@ function parseSourceTemporal(value) {
   }
   return status === "asOf" ? { status, asOf: date } : status === "updatedAt" ? { status, updatedAt: date } : { status, createdAt: date };
 }
-function asRecord(value, label) {
+function asRecord2(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new ContractValidationError("INVALID_OBJECT", `${label} must be an object.`);
   }
@@ -6079,21 +9195,21 @@ var init_model_policy = __esm(() => {
 
 // src/subagents/runtime.ts
 import childProcess from "node:child_process";
-import { createHash as createHash6, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID6 } from "node:crypto";
 import {
   chmodSync,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   linkSync,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync10,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync11,
   realpathSync as realpathSync3,
   renameSync as renameSync6,
   statSync as statSync2,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { basename as basename6, dirname as dirname10, extname as extname6, isAbsolute as isAbsolute6, join as join16, relative as relative4, resolve as resolve8, sep as sep3 } from "node:path";
+import { basename as basename9, dirname as dirname12, extname as extname9, isAbsolute as isAbsolute6, join as join19, relative as relative5, resolve as resolve8, sep as sep4 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { InMemoryCredentialStore, InMemoryModelsStore } from "@earendil-works/pi-ai";
 import {
@@ -6105,24 +9221,24 @@ import {
   SettingsManager
 } from "@earendil-works/pi-coding-agent";
 function resolveExplorerToolsExtensionPath() {
-  const dir = dirname10(runtimePath);
+  const dir = dirname12(runtimePath);
   const candidates = [
-    join16(dir, `explorer-tools-extension${extname6(runtimePath)}`),
-    join16(dir, "subagents", "explorer-tools-extension.js"),
-    join16(dir, "..", "subagents", "explorer-tools-extension.js")
+    join19(dir, `explorer-tools-extension${extname9(runtimePath)}`),
+    join19(dir, "subagents", "explorer-tools-extension.js"),
+    join19(dir, "..", "subagents", "explorer-tools-extension.js")
   ];
   for (const candidate of candidates) {
-    if (existsSync14(candidate))
+    if (existsSync15(candidate))
       return realpathSync3(candidate);
   }
   throw new Error(`AutoRAG explorer tools extension not found; looked in: ${candidates.join(", ")}`);
 }
 function resolvePiSubagentsPackageJson() {
   const require2 = createRequire2(import.meta.url);
-  return join16(dirname10(require2.resolve("pi-subagents")), "package.json");
+  return join19(dirname12(require2.resolve("pi-subagents")), "package.json");
 }
 function resolvePiSubagentsExtension() {
-  return join16(dirname10(resolvePiSubagentsPackageJson()), "src", "extension", "index.ts");
+  return join19(dirname12(resolvePiSubagentsPackageJson()), "src", "extension", "index.ts");
 }
 function resolveSubagentPiBinary() {
   const configured = process.env.PI_SUBAGENT_PI_BINARY?.trim();
@@ -6130,12 +9246,12 @@ function resolveSubagentPiBinary() {
     return configured;
   const require2 = createRequire2(import.meta.url);
   const subagentsPackage = resolvePiSubagentsPackageJson();
-  const packageJsonPath = join16(dirname10(dirname10(subagentsPackage)), "@earendil-works", "pi-coding-agent", "package.json");
+  const packageJsonPath = join19(dirname12(dirname12(subagentsPackage)), "@earendil-works", "pi-coding-agent", "package.json");
   const packageJson = require2(packageJsonPath);
   const bin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.pi;
   if (!bin)
     throw new Error("Mandatory pi-subagents runtime could not resolve the Pi CLI binary");
-  return join16(dirname10(packageJsonPath), bin);
+  return join19(dirname12(packageJsonPath), bin);
 }
 function asToolDefinition(tool) {
   return {
@@ -6144,12 +9260,12 @@ function asToolDefinition(tool) {
   };
 }
 function defaultAgentDir() {
-  return join16(resolveAutoRAGHome(), "pi-agent");
+  return join19(resolveAutoRAGHome(), "pi-agent");
 }
 function ensurePiSettingsFile(agentDir) {
-  const settingsPath = join16(agentDir, "settings.json");
+  const settingsPath = join19(agentDir, "settings.json");
   try {
-    writeFileSync7(settingsPath, "{}", { encoding: "utf8", flag: "wx" });
+    writeFileSync8(settingsPath, "{}", { encoding: "utf8", flag: "wx" });
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST")
       return;
@@ -6172,7 +9288,7 @@ function isRecognizedManagedExplorerDefinition(definition) {
 function replaceExplorerDefinitionAtomically(explorerPath) {
   const temporaryPath = `${explorerPath}.${randomUUID6()}.tmp`;
   try {
-    writeFileSync7(temporaryPath, AUTORAG_EXPLORER_AGENT_DEFINITION, {
+    writeFileSync8(temporaryPath, AUTORAG_EXPLORER_AGENT_DEFINITION, {
       encoding: "utf8",
       flag: "wx",
       mode: 384
@@ -6180,30 +9296,30 @@ function replaceExplorerDefinitionAtomically(explorerPath) {
     chmodSync(temporaryPath, 384);
     renameSync6(temporaryPath, explorerPath);
   } finally {
-    if (existsSync14(temporaryPath))
+    if (existsSync15(temporaryPath))
       unlinkSync4(temporaryPath);
   }
 }
 function ensureMandatoryExplorerAgent(agentDir) {
-  const agentsDir = join16(agentDir, "agents");
-  const explorerPath = join16(agentsDir, "autorag-explorer.md");
-  if (existsSync14(explorerPath)) {
-    const existingDefinition = readFileSync10(explorerPath, "utf8");
+  const agentsDir = join19(agentDir, "agents");
+  const explorerPath = join19(agentsDir, "autorag-explorer.md");
+  if (existsSync15(explorerPath)) {
+    const existingDefinition = readFileSync11(explorerPath, "utf8");
     if (existingDefinition === AUTORAG_EXPLORER_AGENT_DEFINITION)
       return;
     if (!isRecognizedManagedExplorerDefinition(existingDefinition)) {
       throw new Error(`AutoRAG persistent explorer definition at ${explorerPath} is not canonical`);
     }
     replaceExplorerDefinitionAtomically(explorerPath);
-    if (readFileSync10(explorerPath, "utf8") !== AUTORAG_EXPLORER_AGENT_DEFINITION || (statSync2(explorerPath).mode & 511) !== 384) {
+    if (readFileSync11(explorerPath, "utf8") !== AUTORAG_EXPLORER_AGENT_DEFINITION || (statSync2(explorerPath).mode & 511) !== 384) {
       throw new Error(`AutoRAG persistent explorer definition at ${explorerPath} is not canonical`);
     }
     return;
   }
-  mkdirSync10(agentsDir, { recursive: true });
-  const temporaryPath = join16(agentsDir, `.autorag-explorer.${randomUUID6()}.tmp`);
+  mkdirSync11(agentsDir, { recursive: true });
+  const temporaryPath = join19(agentsDir, `.autorag-explorer.${randomUUID6()}.tmp`);
   try {
-    writeFileSync7(temporaryPath, AUTORAG_EXPLORER_AGENT_DEFINITION, {
+    writeFileSync8(temporaryPath, AUTORAG_EXPLORER_AGENT_DEFINITION, {
       encoding: "utf8",
       flag: "wx",
       mode: 384
@@ -6216,18 +9332,18 @@ function ensureMandatoryExplorerAgent(agentDir) {
       }
     }
   } finally {
-    if (existsSync14(temporaryPath))
+    if (existsSync15(temporaryPath))
       unlinkSync4(temporaryPath);
   }
-  if (readFileSync10(explorerPath, "utf8") !== AUTORAG_EXPLORER_AGENT_DEFINITION) {
+  if (readFileSync11(explorerPath, "utf8") !== AUTORAG_EXPLORER_AGENT_DEFINITION) {
     throw new Error(`AutoRAG persistent explorer definition at ${explorerPath} is not canonical`);
   }
 }
 function defaultSessionDir(cwd, agentDir) {
   const canonicalCwd = resolve8(cwd);
   const readablePath = canonicalCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-");
-  const cwdHash = createHash6("sha256").update(canonicalCwd).digest("hex").slice(0, 12);
-  return join16(agentDir, "sessions", `--${readablePath}-${cwdHash}--`);
+  const cwdHash = createHash8("sha256").update(canonicalCwd).digest("hex").slice(0, 12);
+  return join19(agentDir, "sessions", `--${readablePath}-${cwdHash}--`);
 }
 function childEnvironmentFromSpawnOptions(args) {
   const optionsIndex = Array.isArray(args[1]) ? 2 : 1;
@@ -6265,7 +9381,7 @@ function isPiChildSpawn(args, context) {
   return childArgsFromSpawnArguments(args)[0] === context.piBinary;
 }
 function isAsyncSubagentRunnerSpawn(args) {
-  return childArgsFromSpawnArguments(args).some((argument) => typeof argument === "string" && basename6(argument) === "subagent-runner.ts");
+  return childArgsFromSpawnArguments(args).some((argument) => typeof argument === "string" && basename9(argument) === "subagent-runner.ts");
 }
 function createScopedChildProcessModule(context) {
   const originalSpawn = childProcess.spawn.bind(childProcess);
@@ -6287,12 +9403,12 @@ function createScopedChildProcessModule(context) {
   return { ...scopedModule, default: scopedModule };
 }
 function isWithinDirectory(root, candidate) {
-  const relativePath = relative4(root, candidate);
-  return relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${sep3}`) && !isAbsolute6(relativePath);
+  const relativePath = relative5(root, candidate);
+  return relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${sep4}`) && !isAbsolute6(relativePath);
 }
 async function loadScopedPiSubagentsExtension(extensionPath, environment) {
   const packageJsonPath = resolvePiSubagentsPackageJson();
-  const packageRoot = dirname10(packageJsonPath);
+  const packageRoot = dirname12(packageJsonPath);
   const packageRequire = createRequire2(packageJsonPath);
   const jitiModule = packageRequire("jiti");
   if (typeof jitiModule.createJiti !== "function") {
@@ -6300,7 +9416,7 @@ async function loadScopedPiSubagentsExtension(extensionPath, environment) {
   }
   const createJiti = jitiModule.createJiti;
   const baseJiti = createJiti(packageJsonPath, { moduleCache: false, fsCache: false });
-  const utilsPath = join16(packageRoot, "src", "shared", "utils.ts");
+  const utilsPath = join19(packageRoot, "src", "shared", "utils.ts");
   const upstreamUtils = await baseJiti.import(utilsPath);
   if (typeof upstreamUtils.getAgentDir !== "function") {
     throw new Error("pi-subagents did not expose its expected getAgentDir utility");
@@ -6330,11 +9446,11 @@ function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readPiModelsConfig(modelsPath) {
-  if (!existsSync14(modelsPath))
+  if (!existsSync15(modelsPath))
     return { providers: {} };
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync10(modelsPath, "utf8"));
+    parsed = JSON.parse(readFileSync11(modelsPath, "utf8"));
   } catch (error) {
     throw new Error(`AutoRAG could not parse Pi models.json at ${modelsPath}: ${error.message}`, {
       cause: error
@@ -6508,13 +9624,13 @@ async function persistPiModels(modelsPath, roleModels, providerCredentials) {
       }
     }
     temporaryPath = `${modelsPath}.${randomUUID6()}.tmp`;
-    writeFileSync7(temporaryPath, content, { encoding: "utf8", flag: "wx", mode: 384 });
+    writeFileSync8(temporaryPath, content, { encoding: "utf8", flag: "wx", mode: 384 });
     await validatePiModelsFile(temporaryPath, roleModels, "generated");
     lock.assertOwned();
     renameSync6(temporaryPath, modelsPath);
   } finally {
     try {
-      if (temporaryPath && existsSync14(temporaryPath))
+      if (temporaryPath && existsSync15(temporaryPath))
         unlinkSync4(temporaryPath);
     } finally {
       lock.release();
@@ -6579,7 +9695,7 @@ function explorerEnvironmentIdentity(environment) {
     agentDir: environment.agentDir,
     piBinary: environment.piBinary,
     apiKeyName: environment.apiKeyName,
-    apiKeyHash: environment.apiKey === undefined ? undefined : createHash6("sha256").update(environment.apiKey).digest("hex")
+    apiKeyHash: environment.apiKey === undefined ? undefined : createHash8("sha256").update(environment.apiKey).digest("hex")
   });
 }
 function defaultExplorerModel(model) {
@@ -6587,7 +9703,7 @@ function defaultExplorerModel(model) {
 }
 async function createMandatorySubagentSession(options) {
   const agentDir = resolve8(options.agentDir ?? defaultAgentDir());
-  mkdirSync10(agentDir, { recursive: true });
+  mkdirSync11(agentDir, { recursive: true });
   ensureMandatoryExplorerAgent(agentDir);
   const piBinary = resolveSubagentPiBinary();
   const extensionPath = options.extensionPath ?? resolvePiSubagentsExtension();
@@ -6609,7 +9725,7 @@ async function createMandatorySubagentSession(options) {
   const explorerRoleModel = activeRoleModel(explorerModel, "explorer");
   const roleModels = [orchestratorRoleModel, explorerRoleModel];
   validateProviderApiKeyEnvNames(roleModels);
-  const authPath = join16(agentDir, "auth.json");
+  const authPath = join19(agentDir, "auth.json");
   for (const { reference } of roleModels) {
     if (parentProviderCredentials.has(reference.provider))
       continue;
@@ -6618,7 +9734,7 @@ async function createMandatorySubagentSession(options) {
       continue;
     parentProviderCredentials.set(reference.provider, stored.key);
   }
-  const modelsPath = join16(agentDir, "models.json");
+  const modelsPath = join19(agentDir, "models.json");
   const explorerCredential = parentProviderCredentials.get(explorerRoleModel.reference.provider);
   const explorerEnvironment = {
     agentDir,
@@ -6927,12 +10043,12 @@ Required handoff: include temporal metadata.
 });
 
 // src/agent/bash-tool.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { Type as Type2 } from "typebox";
 function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
   return new Promise((resolve9) => {
     const shell = process.platform === "win32" ? "bash.exe" : "/bin/bash";
-    const child = spawn4(shell, ["-c", command], { cwd });
+    const child = spawn7(shell, ["-c", command], { cwd });
     const chunks = [];
     let total = 0;
     let truncated = false;
@@ -6976,7 +10092,7 @@ function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
   });
 }
 function createBashTool(options) {
-  const defaultTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const defaultTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
   const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
   return {
     name: BASH_TOOL_NAME,
@@ -7035,7 +10151,7 @@ function createBashTool(options) {
     }
   };
 }
-var BASH_TOOL_NAME = "bash", DEFAULT_TIMEOUT_MS2 = 120000, DEFAULT_MAX_OUTPUT_BYTES = 131072, bashSchema;
+var BASH_TOOL_NAME = "bash", DEFAULT_TIMEOUT_MS6 = 120000, DEFAULT_MAX_OUTPUT_BYTES = 131072, bashSchema;
 var init_bash_tool = __esm(() => {
   bashSchema = Type2.Object({
     command: Type2.String({
@@ -7585,7 +10701,8 @@ function recordStructuredResultsSession(sessionId, query, details, sessions, mem
     summary: result.summary,
     evidence: result.evidence.map((evidence) => evidence.lineNumber !== undefined ? { excerpt: evidence.excerpt, lineNumber: evidence.lineNumber } : { excerpt: evidence.excerpt }),
     confidence: confidenceFrom(result.confidence),
-    feedbackId: `${sessionId}:${result.number}`
+    feedbackId: `${sessionId}:${result.number}`,
+    source: registry.get(result.number)?.source
   }));
   const answer = details.answer;
   const diagnostics = [];
@@ -7992,7 +11109,7 @@ var init_watch_refresh = __esm(() => {
 // src/agent/agent.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { watch as fsWatch, realpathSync as realpathSync4, statSync as statSync3 } from "node:fs";
-import { dirname as dirname11, join as join17, resolve as resolve9 } from "node:path";
+import { dirname as dirname13, join as join20, resolve as resolve9 } from "node:path";
 import { Agent } from "@earendil-works/pi-agent-core";
 
 class AutoRAGAgent {
@@ -8079,10 +11196,10 @@ class AutoRAGAgent {
     if (options.jikji) {
       this.jikjiClient = new JikjiClient({ ...options.jikji, root: this.workspaceProjectRoot });
     }
-    const memPath = memoryPath ?? join17(resolveAutoRAGHome(), "memory.json");
+    const memPath = memoryPath ?? join20(resolveAutoRAGHome(), "memory.json");
     this.memory = new RetrievalMemory({ storagePath: memPath });
     this.memory.load();
-    this.runLogger = new AutoRAGRunLogger(join17(dirname11(memPath), "logs", "runs.jsonl"));
+    this.runLogger = new AutoRAGRunLogger(join20(dirname13(memPath), "logs", "runs.jsonl"));
     const checkMemoryTool = createCheckMemoryTool(this.memory);
     const searchBM25Tool = createSearchBM25DocumentsTool(() => this.bm25Method);
     const searchDatasourceTool = createSearchDatasourceDocumentsTool(this);
@@ -8835,7 +11952,7 @@ ${allowedRoots}
       written: 0,
       deleted: 0,
       skipped: 0,
-      indexPath: join17(this.workspaceProjectRoot, PARSED_MIRROR_SUBDIR),
+      indexPath: join20(this.workspaceProjectRoot, PARSED_MIRROR_SUBDIR),
       diagnostics
     };
   }
@@ -9946,8 +13063,8 @@ var exports_commands = {};
 __export(exports_commands, {
   runIndex: () => runIndex
 });
-import { existsSync as existsSync15, lstatSync as lstatSync2, rmSync as rmSync5 } from "node:fs";
-import { join as join18, resolve as resolve10, sep as sep4 } from "node:path";
+import { existsSync as existsSync16, lstatSync as lstatSync2, rmSync as rmSync5 } from "node:fs";
+import { join as join21, resolve as resolve10, sep as sep5 } from "node:path";
 async function runIndex(ctx) {
   const sub = ctx.positionals[0];
   if (sub !== "reset" && sub !== "rebuild") {
@@ -9966,7 +13083,7 @@ async function runIndex(ctx) {
   const autoragDir = resolve10(config.workspacePath, ".autorag");
   const targets = targetSubdirs.map((subdir) => resolve10(config.workspacePath, subdir));
   for (const dir of [autoragDir, ...targets]) {
-    if (existsSync15(dir) && lstatSync2(dir).isSymbolicLink()) {
+    if (existsSync16(dir) && lstatSync2(dir).isSymbolicLink()) {
       ctx.stderr(renderError(new Error("Refusing to reset: an index path is a symlink, not a real directory."), {
         json: ctx.json
       }));
@@ -9981,7 +13098,7 @@ async function runIndex(ctx) {
   }
   if (!ctx.flags.yes) {
     if (ctx.promptYesNo) {
-      const ok = await ctx.promptYesNo(`Reset the ${targetNames.join(", ")} indexes under ${join18(config.workspacePath, ".autorag")}?`);
+      const ok = await ctx.promptYesNo(`Reset the ${targetNames.join(", ")} indexes under ${join21(config.workspacePath, ".autorag")}?`);
       if (!ok) {
         ctx.stderr(renderError(new Error("Reset declined."), { json: ctx.json }));
         return 2;
@@ -10040,7 +13157,7 @@ function resolveResetScope(methods) {
   };
 }
 function isWithin(target, base) {
-  const prefix = base.endsWith(sep4) ? base : `${base}${sep4}`;
+  const prefix = base.endsWith(sep5) ? base : `${base}${sep5}`;
   return target === base || target.startsWith(prefix);
 }
 var ALL_RESET_TARGETS, ALL_RESET_TARGET_NAMES;
@@ -10131,7 +13248,7 @@ __export(exports_health, {
 });
 import { mkdtempSync, rmSync as rmSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join19 } from "node:path";
+import { join as join22 } from "node:path";
 import { completeSimple } from "@earendil-works/pi-ai/compat";
 function defaultResolveConfig(input) {
   return resolveConfigReadOnly({ flags: input.flags, cwd: input.cwd, env: input.env });
@@ -10224,7 +13341,7 @@ function sanitizeMessage(raw) {
 function parseTimeoutMs(flags) {
   const raw = flags["timeout-ms"];
   if (raw === undefined || raw === true)
-    return DEFAULT_TIMEOUT_MS3;
+    return DEFAULT_TIMEOUT_MS7;
   const text = typeof raw === "string" ? raw.trim() : "";
   if (text.length === 0)
     return { error: "--timeout-ms requires a value" };
@@ -10332,10 +13449,10 @@ async function defaultOrchestratorProbe(input, signal) {
   }
 }
 async function defaultExplorerProbe(input, signal) {
-  const tempRoot = mkdtempSync(join19(tmpdir3(), "autorag-health-"));
+  const tempRoot = mkdtempSync(join22(tmpdir3(), "autorag-health-"));
   try {
-    const agentDir = join19(tempRoot, "agent");
-    const sessionDir = join19(tempRoot, "sessions");
+    const agentDir = join22(tempRoot, "agent");
+    const sessionDir = join22(tempRoot, "sessions");
     const providerApiKeys = input.providerApiKeys;
     const modelRef = `${input.model.provider}/${input.model.id}`;
     let probeSession;
@@ -10581,7 +13698,7 @@ async function runHealth(ctx, deps = {}) {
   ctx.stdout(renderHealth(report, { json: ctx.json, debug: ctx.debug }));
   return exitCodeFor(topCategory);
 }
-var CATEGORY_PRECEDENCE, SECRET_PATTERNS, DEFAULT_TIMEOUT_MS3 = 1e4, AUTH_ERROR_PATTERNS, NETWORK_ERROR_CODES, NETWORK_ERROR_PATTERNS, HEALTH_EXPLORER_SYSTEM_PROMPT = "You are a health probe. Reply with HEALTH_OK. Do not read any files.";
+var CATEGORY_PRECEDENCE, SECRET_PATTERNS, DEFAULT_TIMEOUT_MS7 = 1e4, AUTH_ERROR_PATTERNS, NETWORK_ERROR_CODES, NETWORK_ERROR_PATTERNS, HEALTH_EXPLORER_SYSTEM_PROMPT = "You are a health probe. Reply with HEALTH_OK. Do not read any files.";
 var init_health = __esm(() => {
   init_runtime();
   init_config();