@autorag/librarian 2.4.0 → 2.4.1

package/dist/cli/index.js

@@ -1,21 +1,15 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
 };
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli/output.ts
 function diagnosticProjection(d) {
@@ -39,13 +33,6 @@ function refreshEnvelope(result) {
     },
     diagnostics: (result.diagnostics ?? []).map(diagnosticProjection)
   };
-  if (result.bm25) {
-    envelope.bm25 = {
-      indexedChunks: result.bm25.indexedChunks,
-      readiness: result.bm25.readiness,
-      engine: result.bm25.engine
-    };
-  }
   if (result.datasources && result.datasources.length > 0) {
     envelope.datasources = result.datasources.map((ds) => ({
       ok: ds.ok,
@@ -66,9 +53,6 @@ function renderRefreshHuman(result, debug) {
   const lines = [];
   lines.push("refresh: ok");
   lines.push(`  counts: scanned=${result.scanned} written=${result.written} deleted=${result.deleted} skipped=${result.skipped}`);
-  if (result.bm25) {
-    lines.push(`  bm25: indexedChunks=${result.bm25.indexedChunks} readiness=${result.bm25.readiness} engine=${result.bm25.engine}`);
-  }
   if (result.datasources && result.datasources.length > 0) {
     for (const ds of result.datasources) {
       lines.push(`  datasource: ok=${ds.ok} skill=${ds.skill} instanceId=${ds.instanceId} indexedAt=${ds.indexedAt}`);
@@ -102,8 +86,6 @@ function renderStatusHuman(status, debug) {
   }
   const comps = status.components;
   const compParts = [];
-  if (comps.bm25)
-    compParts.push(`bm25=${comps.bm25}`);
   if (comps.minsync)
     compParts.push(`minsync=${comps.minsync}`);
   if (comps.jikji)
@@ -691,7 +673,7 @@ class ClawGalleryClient {
   }
 }
 function spawnCli(binary, args, env, options, signal) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     const portable = portableSpawnCommand(binary, args);
     const child = spawn(portable.command, [...portable.args], { env, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
@@ -732,7 +714,7 @@ function spawnCli(binary, args, env, options, signal) {
       settled = true;
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abort);
-      resolve2({
+      resolve({
         ok: false,
         stdout,
         stderr: error.code === "ENOENT" ? "clawgallery binary not found" : "clawgallery could not start",
@@ -746,7 +728,7 @@ function spawnCli(binary, args, env, options, signal) {
       settled = true;
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abort);
-      resolve2({
+      resolve({
         ok: reason === undefined && code === 0,
         stdout,
         stderr: stderr.slice(0, max),
@@ -1531,7 +1513,7 @@ function renderTable(table) {
     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}`) ?? ""));
+  const rows = Array.from({ length: table.rowCount }, (_, row) => Array.from({ length: table.columnCount }, (_, column) => cellsByPosition.get(`${row}:${column}`) ?? ""));
   return [
     `| ${header.join(" | ")} |`,
     `| ${header.map(() => "---").join(" | ")} |`,
@@ -1992,7 +1974,7 @@ async function readZipXmlText(bytes, pathPattern) {
 }
 async function readXmlFile(file, remainingBytes) {
   const stream = file.nodeStream("nodebuffer");
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve, reject) => {
     const chunks = [];
     let totalBytes = 0;
     stream.on("data", (chunk) => {
@@ -2006,7 +1988,7 @@ async function readXmlFile(file, remainingBytes) {
       chunks.push(buffer);
     });
     stream.on("error", reject);
-    stream.on("end", () => resolve4(Buffer2.concat(chunks).toString("utf8")));
+    stream.on("end", () => resolve(Buffer2.concat(chunks).toString("utf8")));
   });
 }
 function uncompressedSize(file) {
@@ -2112,8 +2094,8 @@ function tesseractOcr(input) {
   let cleanupReject = () => {
     return;
   };
-  const cleanup = new Promise((resolve4, reject) => {
-    cleanupResolve = resolve4;
+  const cleanup = new Promise((resolve, reject) => {
+    cleanupResolve = resolve;
     cleanupReject = reject;
   });
   const result = runTesseractOcr(input, cleanupResolve, cleanupReject);
@@ -2122,7 +2104,7 @@ function tesseractOcr(input) {
 async function runTesseractOcr(input, cleanupResolve, cleanupReject) {
   let worker;
   let termination;
-  const terminate2 = async () => {
+  const terminate = async () => {
     if (worker === undefined)
       return;
     termination ??= worker.terminate().then(() => {
@@ -2132,7 +2114,7 @@ async function runTesseractOcr(input, cleanupResolve, cleanupReject) {
   };
   const abort = () => {
     if (worker !== undefined) {
-      terminate2().then(cleanupResolve, cleanupReject);
+      terminate().then(cleanupResolve, cleanupReject);
     }
   };
   input.signal.addEventListener("abort", abort, { once: true });
@@ -2144,18 +2126,18 @@ async function runTesseractOcr(input, cleanupResolve, cleanupReject) {
     return result.data.text;
   } finally {
     input.signal.removeEventListener("abort", abort);
-    await terminate2().then(cleanupResolve, cleanupReject);
+    await terminate().then(cleanupResolve, cleanupReject);
   }
 }
 function withTimeout(operation, timeoutMs, onTimeout) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
       onTimeout();
       operation.cleanup.finally(() => reject(new Error(`OCR timed out after ${timeoutMs}ms`)));
     }, timeoutMs);
     operation.result.then((value) => {
       clearTimeout(timeout);
-      resolve4(value);
+      resolve(value);
     }, (error) => {
       clearTimeout(timeout);
       operation.cleanup.then(() => reject(error), (cleanupError) => reject(cleanupError));
@@ -2438,17 +2420,17 @@ import { extname as extname4 } from "node:path";
 class ParserRegistry {
   parsersByExtension = new Map;
   constructor(parsers = []) {
-    for (const parser2 of parsers) {
-      this.register(parser2);
+    for (const parser of parsers) {
+      this.register(parser);
     }
   }
-  register(parser2) {
-    for (const extension of parser2.extensions) {
+  register(parser) {
+    for (const extension of parser.extensions) {
       const normalized = normalizeExtension(extension);
       if (this.parsersByExtension.has(normalized)) {
         throw new Error(`Parser extension "${normalized}" is already registered`);
       }
-      this.parsersByExtension.set(normalized, parser2);
+      this.parsersByExtension.set(normalized, parser);
     }
   }
   getForVirtualPath(virtualPath) {
@@ -2812,11 +2794,11 @@ async function loadMirroredDocuments(root, entries, skillName, instanceId, remot
   for (const entry of entries) {
     try {
       const sourcePath = mirrorFilePath(root, entry.path);
-      const parser2 = registry.getForVirtualPath(entry.path);
-      if (parser2 === undefined)
+      const parser = registry.getForVirtualPath(entry.path);
+      if (parser === undefined)
         continue;
       const bytes = await readFile3(sourcePath);
-      const parsed = await parser2.parse({ virtualPath: entry.path, sourcePath, bytes });
+      const parsed = await parser.parse({ virtualPath: entry.path, sourcePath, bytes });
       for (const diagnostic of parsed.diagnostics ?? []) {
         warnings.push(`${diagnostic.code}: ${diagnostic.message}`);
       }
@@ -2833,8 +2815,8 @@ async function loadMirroredDocuments(root, entries, skillName, instanceId, remot
 }
 function defaultParserExtensions() {
   const extensions = new Set;
-  for (const parser2 of createDefaultParserRegistry().list()) {
-    for (const extension of parser2.extensions) {
+  for (const parser of createDefaultParserRegistry().list()) {
+    for (const extension of parser.extensions) {
       extensions.add(extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`);
     }
   }
@@ -3588,7 +3570,7 @@ function commonArgs(options) {
   return options.configPath === undefined ? [] : ["--config", options.configPath];
 }
 function spawnDiscrawl(request) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve) => {
     const { options, args, env, signal } = request;
     const portable = portableSpawnCommand(options.binaryPath ?? DEFAULT_DISCRAWL_BINARY, args);
     const child = spawn3(portable.command, [...portable.args], {
@@ -3636,7 +3618,7 @@ function spawnDiscrawl(request) {
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
       const reason = error.code === "ENOENT" ? "binary-missing" : "spawn-error";
-      resolve4({ ok: false, reason, stdout: stdout.text, stderr: describeSpawnFailure(reason), code: null });
+      resolve({ ok: false, reason, stdout: stdout.text, stderr: describeSpawnFailure(reason), code: null });
     });
     child.on("close", (code) => {
       if (settled)
@@ -3645,10 +3627,10 @@ function spawnDiscrawl(request) {
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
       if (finalReason !== undefined) {
-        resolve4({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
+        resolve({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
         return;
       }
-      resolve4({
+      resolve({
         ok: code === 0,
         reason: code === 0 ? undefined : "nonzero-exit",
         stdout: stdout.text,
@@ -4271,8 +4253,8 @@ class DiscrawlSkill {
     };
   }
 }
-function failureCode(failure2, fallback) {
-  switch (failure2.reason) {
+function failureCode(failure, fallback) {
+  switch (failure.reason) {
     case "binary-missing":
     case "spawn-error":
     case "timeout":
@@ -4284,9 +4266,9 @@ function failureCode(failure2, fallback) {
       return fallback;
   }
 }
-function describe(failure2) {
-  const detail = failure2.stderr.length > 0 ? `: ${failure2.stderr}` : "";
-  return `${failure2.reason}${detail}`;
+function describe(failure) {
+  const detail = failure.stderr.length > 0 ? `: ${failure.stderr}` : "";
+  return `${failure.reason}${detail}`;
 }
 var DISCORD_DATASOURCE_ID2 = "discord", DISCORD_SKILL_TYPE = "discord-archive", DEFAULT_INSTANCE_ID2 = "default", DEFAULT_POLLING_INTERVAL_MS2, DEFAULT_DISCORD_TAGS2;
 var init_skill3 = __esm(() => {
@@ -4425,228 +4407,6 @@ var init_github = __esm(() => {
   init_skill4();
 });
 
-// src/datasource/skills/gmail/himalaya-connector.ts
-import { spawn as spawn4 } from "node:child_process";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname5, join as join7 } from "node:path";
-
-class HimalayaConnector {
-  options;
-  runner;
-  constructor(options = {}) {
-    this.options = options;
-    this.runner = options.runner ?? ((args, timeoutMs) => runBinary2(options.binaryPath ?? DEFAULT_BINARY3, args, timeoutMs, {
-      ...options.configPath === undefined ? {} : { HIMALAYA_CONFIG: options.configPath }
-    }));
-  }
-  async fetch() {
-    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS4;
-    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS3;
-    const accountArgs = this.options.account !== undefined ? ["--account", this.options.account] : [];
-    const mailboxArgs = this.options.folder !== undefined ? ["--mailbox", this.options.folder] : [];
-    const state = this.loadState();
-    const listArgs = [
-      ...accountArgs,
-      "--json",
-      "envelope",
-      "list",
-      ...mailboxArgs,
-      "--page-size",
-      String(this.options.pageSize ?? DEFAULT_PAGE_SIZE)
-    ];
-    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}
-${listResult.stdout}`),
-        message: diagnosticFailure(listResult)
-      };
-    }
-    let envelopes;
-    try {
-      envelopes = parseEnvelopes(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;
-    const nextFingerprints = { ...state.fingerprints };
-    const listedDocIds = new Set;
-    for (const raw of envelopes.slice(0, maxDocuments)) {
-      const envelope = asRecord(raw);
-      const id = asString(envelope?.id);
-      if (envelope === undefined || id === undefined)
-        continue;
-      const docId = `${account}-${folder}-${id}`;
-      listedDocIds.add(docId);
-      const fingerprint = envelopeFingerprint(envelope);
-      if (state.fingerprints[docId] === fingerprint)
-        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 = "";
-      let bodyRead = false;
-      try {
-        const readResult = await this.runner([...accountArgs, "--json", "message", "read", ...mailboxArgs, id], timeoutMs);
-        if (readResult.ok) {
-          body = readResult.stdout.trim().slice(0, MAX_BODY_CHARS);
-          bodyRead = true;
-        } 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,
-        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)
-          } : {}
-        }
-      });
-      if (bodyRead)
-        nextFingerprints[docId] = fingerprint;
-    }
-    if (envelopes.length <= maxDocuments) {
-      for (const docId of Object.keys(state.fingerprints)) {
-        if (!listedDocIds.has(docId))
-          delete nextFingerprints[docId];
-      }
-    }
-    const warnings = readFailures > 0 ? [`${readFailures} message(s) failed to read`] : undefined;
-    this.saveState({ version: STATE_VERSION, fingerprints: nextFingerprints });
-    const deletedDocIds = envelopes.length <= maxDocuments ? Object.keys(state.fingerprints).filter((docId) => !listedDocIds.has(docId)) : [];
-    return {
-      ok: true,
-      documents,
-      changed: Object.keys(nextFingerprints).length !== Object.keys(state.fingerprints).length || documents.length > 0,
-      ...deletedDocIds.length > 0 ? { deletedDocIds } : {},
-      ...warnings !== undefined ? { warnings } : {}
-    };
-  }
-  loadState() {
-    const path = this.statePath();
-    if (path === undefined)
-      return { version: STATE_VERSION, fingerprints: {} };
-    try {
-      const parsed = JSON.parse(readFileSync6(path, "utf8"));
-      if (parsed.version !== STATE_VERSION || parsed.fingerprints === undefined) {
-        return { version: STATE_VERSION, fingerprints: {} };
-      }
-      return { version: STATE_VERSION, fingerprints: parsed.fingerprints };
-    } catch {
-      return { version: STATE_VERSION, fingerprints: {} };
-    }
-  }
-  saveState(state) {
-    const path = this.statePath();
-    if (path === undefined)
-      return;
-    try {
-      mkdirSync4(dirname5(path), { recursive: true });
-      writeFileSync4(path, `${JSON.stringify(state)}
-`, "utf8");
-    } catch {}
-  }
-  statePath() {
-    if (this.options.workspaceRoot === undefined)
-      return;
-    return join7(this.options.workspaceRoot, ".autorag", "datasources", sanitizeIdSegment("gmail"), sanitizeIdSegment(this.options.account ?? "default"), sanitizeIdSegment(this.options.folder ?? "INBOX"), "himalaya-state.json");
-  }
-}
-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(diagnostic) {
-  const lower = diagnostic.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 diagnosticFailure(result) {
-  const raw = result.stderr.trim() || result.stdout.trim();
-  if (raw.length === 0)
-    return `himalaya exited with code ${result.code ?? "unknown"}`;
-  return boundDiagnosticText(raw.replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/giu, "<redacted-email>").replace(/(?:\/Users|\/home|[A-Z]:\\Users)[^\s"']+/gu, "<redacted-path>").replace(/(?:password|passwd|token|secret)\s*[:=]\s*\S+/giu, "$1=<redacted>"));
-}
-function parseEnvelopes(stdout) {
-  const parsed = JSON.parse(stdout);
-  if (Array.isArray(parsed))
-    return asArray(parsed);
-  const record = asRecord(parsed);
-  return asArray(record?.envelopes ?? record?.data);
-}
-function envelopeFingerprint(envelope) {
-  return JSON.stringify({
-    subject: envelope.subject,
-    date: envelope.date,
-    from: envelope.from,
-    to: envelope.to,
-    flags: envelope.flags
-  });
-}
-function runBinary2(binary, args, timeoutMs, env, cwd) {
-  return new Promise((resolvePromise) => {
-    const command = portableSpawnCommand(binary, args);
-    const child = spawn4(command.command, command.args, {
-      ...env === undefined ? {} : { env: { ...process.env, ...env } },
-      ...cwd === undefined ? {} : { cwd },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString("utf8");
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString("utf8");
-    });
-    child.on("error", () => {
-      clearTimeout(timer);
-      resolvePromise({ ok: false, stdout, stderr, code: null });
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      resolvePromise({ ok: code === 0, stdout, stderr, code });
-    });
-  });
-}
-var DEFAULT_BINARY3 = "himalaya", DEFAULT_PAGE_SIZE = 100, DEFAULT_MAX_DOCUMENTS3 = 50, DEFAULT_TIMEOUT_MS4 = 30000, MAX_BODY_CHARS = 50000, STATE_VERSION = 1;
-var init_himalaya_connector = __esm(() => {
-  init_portable_spawn();
-  init_connector();
-});
-
 // src/datasource/skills/gmail/connector.ts
 class GmailConnector {
   options;
@@ -4665,7 +4425,7 @@ class GmailConnector {
       signal
     };
     const maxPages = this.options.maxPages ?? DEFAULT_MAX_PAGES2;
-    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS4;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS3;
     const messageIds = [];
     let pageToken;
     for (let page = 0;page < maxPages && messageIds.length < maxDocuments; page += 1) {
@@ -4713,7 +4473,7 @@ class GmailConnector {
       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 body = (extractBody(payload) ?? asString(message.snippet) ?? "").slice(0, MAX_BODY_CHARS);
       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;
@@ -4779,7 +4539,7 @@ function decodeBase64Url(data) {
     return "";
   }
 }
-var DEFAULT_BASE_URL2 = "https://gmail.googleapis.com/gmail/v1", DEFAULT_TOKEN_ENV2 = "GMAIL_ACCESS_TOKEN", DEFAULT_MAX_PAGES2 = 10, DEFAULT_MAX_DOCUMENTS4 = 500, MAX_BODY_CHARS2 = 50000;
+var DEFAULT_BASE_URL2 = "https://gmail.googleapis.com/gmail/v1", DEFAULT_TOKEN_ENV2 = "GMAIL_ACCESS_TOKEN", DEFAULT_MAX_PAGES2 = 10, DEFAULT_MAX_DOCUMENTS3 = 500, MAX_BODY_CHARS = 50000;
 var init_connector3 = () => {};
 
 // src/datasource/skills/gmail/skill.ts
@@ -4791,14 +4551,11 @@ var init_skill5 = __esm(() => {
     skillName: "gmail",
     skillType: "gmail-account",
     description: "Gmail datasource",
-    capabilities: ["email", "api", "external-cli", "polling", "bm25", "incremental"],
+    capabilities: ["email", "api", "polling", "bm25", "incremental"],
     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.",
-      "When the Himalaya backend is selected, indexing is incremental and lexical BM25 retrieval is local to AutoRAG; Himalaya itself does not provide semantic embeddings."
-    ]
+    manifestNotes: ["Label visibility is bounded by the server-configured OAuth token."]
   };
   GmailSkill = class GmailSkill extends ConnectorDatasourceSkill {
     constructor(options = {}) {
@@ -4814,7 +4571,6 @@ var init_skill5 = __esm(() => {
 // src/datasource/skills/gmail/index.ts
 var init_gmail = __esm(() => {
   init_connector3();
-  init_himalaya_connector();
   init_skill5();
 });
 
@@ -4823,7 +4579,7 @@ var DEFAULT_KATOK_BINARY = "katok", DEFAULT_KATOK_TIMEOUT_MS = 60000, DEFAULT_KA
 var init_types2 = () => {};
 
 // src/datasource/skills/katok/client.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 
 class KatokClient {
   options;
@@ -4925,10 +4681,10 @@ class KatokClient {
   }
 }
 function spawnKatok(request) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve) => {
     const { options, args, env, signal } = request;
     const portable = portableSpawnCommand(commandFor(options.binaryPath), args);
-    const child = spawn5(portable.command, [...portable.args], {
+    const child = spawn4(portable.command, [...portable.args], {
       env,
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -4972,7 +4728,7 @@ function spawnKatok(request) {
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
       const reason = error.code === "ENOENT" ? "binary-missing" : "spawn-error";
-      resolve4({ ok: false, reason, stdout: stdout.text, stderr: describeSpawnFailure2(reason), code: null });
+      resolve({ ok: false, reason, stdout: stdout.text, stderr: describeSpawnFailure2(reason), code: null });
     });
     child.on("close", (code) => {
       if (settled)
@@ -4981,10 +4737,10 @@ function spawnKatok(request) {
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
       if (finalReason !== undefined) {
-        resolve4({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
+        resolve({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
         return;
       }
-      resolve4({
+      resolve({
         ok: code === 0,
         reason: code === 0 ? undefined : "nonzero-exit",
         stdout: stdout.text,
@@ -5483,7 +5239,7 @@ var init_katok = __esm(() => {
 
 // src/datasource/skills/mail-export/connector.ts
 import { readdir, readFile as readFile4, stat } from "node:fs/promises";
-import { basename as basename3, dirname as dirname6, extname as extname5, join as join8 } from "node:path";
+import { basename as basename3, dirname as dirname5, extname as extname5, join as join7 } from "node:path";
 import { simpleParser as simpleParser2 } from "mailparser";
 
 class MailExportConnector {
@@ -5495,7 +5251,7 @@ class MailExportConnector {
     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_DOCUMENTS5;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS4;
     const maxBytes = this.options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE2;
     const files = [];
     let missingPaths = 0;
@@ -5509,7 +5265,7 @@ class MailExportConnector {
               continue;
             const extension = extname5(entry.name).toLowerCase();
             if (extension === ".eml" || extension === ".mbox") {
-              files.push(join8(entry.parentPath, entry.name));
+              files.push(join7(entry.parentPath, entry.name));
             }
           }
         } else if (info.isFile()) {
@@ -5544,7 +5300,7 @@ class MailExportConnector {
         continue;
       }
       const stem = basename3(file, extname5(file));
-      const mailboxDir = basename3(dirname6(file));
+      const mailboxDir = basename3(dirname5(file));
       const hierarchy = ["mailboxes", mailboxDir, stem];
       const extension = extname5(file).toLowerCase();
       const rawMessages = extension === ".mbox" ? splitMbox(bytes.toString("utf8")) : [bytes.toString("utf8")];
@@ -5556,7 +5312,7 @@ class MailExportConnector {
           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 body = (parsed.text ?? "").trim().slice(0, MAX_BODY_CHARS2);
           const headerBlock = [
             `Subject: ${subject}`,
             ...from !== undefined ? [`From: ${from}`] : [],
@@ -5613,7 +5369,7 @@ function splitMbox(text) {
 `));
   return messages.filter((message) => message.trim().length > 0);
 }
-var DEFAULT_MAX_DOCUMENTS5 = 500, DEFAULT_MAX_BYTES_PER_FILE2, MAX_BODY_CHARS3 = 50000, MBOX_SEPARATOR;
+var DEFAULT_MAX_DOCUMENTS4 = 500, DEFAULT_MAX_BYTES_PER_FILE2, MAX_BODY_CHARS2 = 50000, MBOX_SEPARATOR;
 var init_connector4 = __esm(() => {
   DEFAULT_MAX_BYTES_PER_FILE2 = 50 * 1024 * 1024;
   MBOX_SEPARATOR = /^From .*\d{4}$/mu;
@@ -5654,21 +5410,21 @@ var init_mail_export = __esm(() => {
 });
 
 // src/datasource/skills/mailcrawl/config.ts
-import { chmodSync, mkdirSync as mkdirSync5 } from "node:fs";
+import { chmodSync, mkdirSync as mkdirSync4 } from "node:fs";
 function validateMailcrawlInstanceId(instanceId) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(instanceId)) {
     throw new Error("mailcrawl instanceId must be a safe single path segment");
   }
 }
 function ensurePrivateMailcrawlDataDir(path) {
-  mkdirSync5(path, { recursive: true, mode: 448 });
+  mkdirSync4(path, { recursive: true, mode: 448 });
   if (process.platform !== "win32")
     chmodSync(path, 448);
 }
 var init_config = () => {};
 
 // src/datasource/skills/mailcrawl/client.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 
 class MailcrawlClient {
   options;
@@ -5762,7 +5518,7 @@ class MailcrawlClient {
     }
     if (dataDir !== undefined)
       env.MAILCRAWL_DATA_DIR = dataDir;
-    return spawnMailcrawl(this.options.binaryPath ?? DEFAULT_BINARY4, args, env, this.options, signal);
+    return spawnMailcrawl(this.options.binaryPath ?? DEFAULT_BINARY3, args, env, this.options, signal);
   }
   async index(signal) {
     const result = await this.run(["index", "--json"], signal);
@@ -5782,7 +5538,7 @@ class MailcrawlClient {
 function spawnMailcrawl(binary, args, env, options, signal) {
   return new Promise((resolveResult) => {
     const portable = portableSpawnCommand(binary, args);
-    const child = spawn6(portable.command, portable.args, {
+    const child = spawn5(portable.command, portable.args, {
       env,
       detached: process.platform !== "win32",
       stdio: ["ignore", "pipe", "pipe"]
@@ -5792,7 +5548,7 @@ function spawnMailcrawl(binary, args, env, options, signal) {
     const timer = setTimeout(() => {
       reason = "timeout";
       terminate4(child);
-    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS5);
+    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS4);
     const abort = () => {
       reason = "aborted";
       terminate4(child);
@@ -5965,7 +5721,7 @@ function truncateUtf8(value, maxBytes) {
   }
   return "";
 }
-var DEFAULT_BINARY4 = "mailcrawl", DEFAULT_TIMEOUT_MS5 = 60000, DEFAULT_MAX_BUFFER_BYTES2 = 1048576, SAFE_ENV_KEYS, SAFE_MAILCRAWL_ENV_KEYS, REMOTE_EMBEDDING_ENV_KEYS;
+var DEFAULT_BINARY3 = "mailcrawl", DEFAULT_TIMEOUT_MS4 = 60000, DEFAULT_MAX_BUFFER_BYTES2 = 1048576, SAFE_ENV_KEYS, SAFE_MAILCRAWL_ENV_KEYS, REMOTE_EMBEDDING_ENV_KEYS;
 var init_client4 = __esm(() => {
   init_portable_spawn();
   init_config();
@@ -6212,7 +5968,7 @@ var init_mailcrawl = __esm(() => {
 });
 
 // src/datasource/crawler-client.ts
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 
 class CrawlerCliClient {
   profile;
@@ -6247,9 +6003,9 @@ class CrawlerCliClient {
   }
 }
 function spawnCrawler(command, args, env, signal, options, cwd) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve) => {
     const portable = portableSpawnCommand(command, args);
-    const child = spawn7(portable.command, [...portable.args], {
+    const child = spawn6(portable.command, [...portable.args], {
       env,
       ...cwd === undefined ? {} : { cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -6262,7 +6018,7 @@ function spawnCrawler(command, args, env, signal, options, cwd) {
     const timeout = setTimeout(() => {
       finalReason = "timeout";
       terminate5(child);
-    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS6);
+    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS5);
     const abortHandler = () => {
       finalReason = "aborted";
       terminate5(child);
@@ -6292,7 +6048,7 @@ function spawnCrawler(command, args, env, signal, options, cwd) {
       settled = true;
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
-      resolve4({
+      resolve({
         ok: false,
         reason: error.code === "ENOENT" ? "binary-missing" : "spawn-error",
         stdout: stdout.text,
@@ -6306,7 +6062,7 @@ function spawnCrawler(command, args, env, signal, options, cwd) {
       settled = true;
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
-      resolve4({
+      resolve({
         ok: code === 0 && finalReason === undefined,
         ...finalReason !== undefined ? { reason: finalReason } : code === 0 ? {} : { reason: "nonzero-exit" },
         stdout: stdout.text,
@@ -6354,7 +6110,7 @@ function toFailure3(binaryName, result, reason) {
     code: result.code
   };
 }
-var DEFAULT_TIMEOUT_MS6 = 60000, DEFAULT_MAX_BUFFER_BYTES3 = 1048576, SAFE_ENV_KEYS2;
+var DEFAULT_TIMEOUT_MS5 = 60000, DEFAULT_MAX_BUFFER_BYTES3 = 1048576, SAFE_ENV_KEYS2;
 var init_crawler_client = __esm(() => {
   init_portable_spawn();
   SAFE_ENV_KEYS2 = new Set([
@@ -6707,15 +6463,15 @@ var init_notion = __esm(() => {
 });
 
 // src/datasource/skills/obsidian/paths.ts
-import { join as join9 } from "node:path";
+import { join as join8 } from "node:path";
 function obsidianDatasourceRoot(workspaceRoot, instanceId) {
-  return join9(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, OBSIDIAN_DATASOURCE_DIRNAME, instanceId);
+  return join8(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, OBSIDIAN_DATASOURCE_DIRNAME, instanceId);
 }
 function obsidianQmdConfigDir(workspaceRoot, instanceId) {
-  return join9(obsidianDatasourceRoot(workspaceRoot, instanceId), "config");
+  return join8(obsidianDatasourceRoot(workspaceRoot, instanceId), "config");
 }
 function obsidianQmdCacheDir(workspaceRoot, instanceId) {
-  return join9(obsidianDatasourceRoot(workspaceRoot, instanceId), "cache");
+  return join8(obsidianDatasourceRoot(workspaceRoot, instanceId), "cache");
 }
 function stripEdgeDashes(value) {
   let start = 0;
@@ -6737,8 +6493,8 @@ var init_paths3 = () => {};
 var DEFAULT_QMD_BINARY = "qmd", DEFAULT_QMD_TIMEOUT_MS = 60000, DEFAULT_QMD_MAX_BUFFER_BYTES = 1048576;
 
 // src/datasource/skills/obsidian/client.ts
-import { spawn as spawn8 } from "node:child_process";
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { spawn as spawn7 } from "node:child_process";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { isAbsolute as isAbsolute3, resolve as resolve4 } from "node:path";
 
 class QmdClient {
@@ -6758,10 +6514,10 @@ class QmdClient {
     const cacheDir = obsidianQmdCacheDir(workspaceRoot, instanceId);
     try {
       if (this.options.configPath === undefined) {
-        mkdirSync6(configDir, { recursive: true });
-        writeFileSync5(resolve4(configDir, "index.yml"), renderIndexYaml(collectionName, vaultPath), "utf8");
+        mkdirSync5(configDir, { recursive: true });
+        writeFileSync4(resolve4(configDir, "index.yml"), renderIndexYaml(collectionName, vaultPath), "utf8");
       }
-      mkdirSync6(cacheDir, { recursive: true });
+      mkdirSync5(cacheDir, { recursive: true });
     } catch (error) {
       return failure3("spawn-error", error instanceof Error ? error.message : "failed to write qmd config");
     }
@@ -6862,7 +6618,7 @@ function isAllowedEnvKey2(key) {
 function spawnQmd(request) {
   return new Promise((resolveResult) => {
     const portable = portableSpawnCommand(request.binaryPath ?? DEFAULT_QMD_BINARY, request.args);
-    const child = spawn8(portable.command, [...portable.args], {
+    const child = spawn7(portable.command, [...portable.args], {
       env: request.env,
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -7408,7 +7164,7 @@ class RssConnector {
     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_DOCUMENTS6;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS5;
     const maxItemsPerFeed = this.options.maxItemsPerFeed ?? DEFAULT_MAX_ITEMS_PER_FEED;
     const documents = [];
     const warnings = [];
@@ -7541,7 +7297,7 @@ function stripHtml(text) {
 function present(item) {
   return item !== undefined;
 }
-var DEFAULT_MAX_DOCUMENTS6 = 500, DEFAULT_MAX_ITEMS_PER_FEED = 100, DEFAULT_FEED_TIMEOUT_MS = 30000, MAX_CONTENT_CHARS2 = 20000, ACCEPT_HEADER = "application/rss+xml, application/atom+xml, application/xml, text/xml";
+var DEFAULT_MAX_DOCUMENTS5 = 500, DEFAULT_MAX_ITEMS_PER_FEED = 100, DEFAULT_FEED_TIMEOUT_MS = 30000, MAX_CONTENT_CHARS2 = 20000, ACCEPT_HEADER = "application/rss+xml, application/atom+xml, application/xml, text/xml";
 var init_connector5 = () => {};
 
 // src/datasource/skills/rss/skill.ts
@@ -7713,7 +7469,7 @@ var init_slack = __esm(() => {
 });
 
 // src/datasource/skills/spotlight/connector.ts
-import { spawn as spawn9 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import { readFile as fsReadFile, stat as stat2 } from "node:fs/promises";
 import { basename as basename4, extname as extname6 } from "node:path";
@@ -7737,7 +7493,7 @@ class SpotlightConnector {
     if (queries.length === 0) {
       return { ok: false, reason: "not-configured", message: "no spotlight queries configured" };
     }
-    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS7;
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
     const status = await this.run("mdutil", ["-s", "/"], timeoutMs);
     if (status.ok && /indexing disabled/iu.test(status.stdout)) {
       return {
@@ -7747,7 +7503,7 @@ class SpotlightConnector {
       };
     }
     const maxPerQuery = this.options.maxResultsPerQuery ?? DEFAULT_MAX_RESULTS_PER_QUERY;
-    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS7;
+    const maxDocuments = this.options.maxDocuments ?? DEFAULT_MAX_DOCUMENTS6;
     const seen = new Set;
     const paths = [];
     let mdfindMissing = false;
@@ -7831,8 +7587,8 @@ class SpotlightConnector {
     return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
   }
 }
-var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS7 = 300, DEFAULT_MAX_BYTES_PER_FILE3, DEFAULT_TIMEOUT_MS7 = 15000, MAX_CONTENT_CHARS3 = 1e5, MAX_BUFFER_BYTES, FDA_GUIDANCE = "grant Full Disk Access to the terminal or app running AutoRAG (System Settings -> Privacy & Security -> Full Disk Access), then restart it", spawnRunner = (command, args, timeoutMs) => new Promise((resolve5) => {
-  const child = spawn9(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
+var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS6 = 300, DEFAULT_MAX_BYTES_PER_FILE3, DEFAULT_TIMEOUT_MS6 = 15000, MAX_CONTENT_CHARS3 = 1e5, MAX_BUFFER_BYTES, FDA_GUIDANCE = "grant Full Disk Access to the terminal or app running AutoRAG (System Settings -> Privacy & Security -> Full Disk Access), then restart it", spawnRunner = (command, args, timeoutMs) => new Promise((resolve) => {
+  const child = spawn8(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
   let stdout = "";
   let stderr = "";
   let settled = false;
@@ -7841,7 +7597,7 @@ var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS7 = 300, DEFAULT_M
       return;
     settled = true;
     clearTimeout(timer);
-    resolve5(result);
+    resolve(result);
   };
   const timer = setTimeout(() => {
     child.kill("SIGKILL");
@@ -8183,12 +7939,19 @@ function buildDatasourceSkills(config, workspaceRoot) {
     }
     const normalizedEntry = entry.instanceId === undefined && entry.type !== undefined ? { ...entry, instanceId: name } : entry;
     const skill = builder(normalizedEntry, workspaceRoot, name);
+    if (skill === undefined) {
+      unknown.push(name);
+      continue;
+    }
     const hasChannelFilter = (entry.channels?.ids?.length ?? 0) > 0 || (entry.channels?.names?.length ?? 0) > 0;
-    const aliased = name !== templateName || hasChannelFilter ? new AliasedDatasourceSkill(skill, {
-      alias: name,
-      ...entry.channels?.ids !== undefined ? { channelIds: entry.channels.ids } : {},
-      ...entry.channels?.names !== undefined ? { channelNames: entry.channels.names } : {}
-    }) : skill;
+    let aliased = skill;
+    if (name !== templateName || hasChannelFilter) {
+      aliased = new AliasedDatasourceSkill(skill, {
+        alias: name,
+        ...entry.channels?.ids !== undefined ? { channelIds: entry.channels.ids } : {},
+        ...entry.channels?.names !== undefined ? { channelNames: entry.channels.names } : {}
+      });
+    }
     skills.push(typeof entry.description === "string" && entry.description.trim().length > 0 ? new DescribedDatasourceSkill(aliased, entry.description.trim()) : aliased);
   }
   return { skills, unknown };
@@ -8199,7 +7962,6 @@ var init_factory = __esm(() => {
   init_cloud_drive();
   init_discrawl();
   init_github();
-  init_himalaya_connector();
   init_gmail();
   init_katok();
   init_mail_export();
@@ -8318,17 +8080,8 @@ var init_factory = __esm(() => {
     }),
     gmail: (config, workspaceRoot, registrationName) => {
       const connector = config.connector;
-      if (connector?.backend === "himalaya") {
-        const { backend: _backend, ...himalayaOptions } = connector;
-        return new GmailSkill({
-          ...common(config, workspaceRoot),
-          skillName: registrationName,
-          connector: new HimalayaConnector({
-            ...himalayaOptions,
-            ...workspaceRoot !== undefined ? { workspaceRoot } : {}
-          })
-        });
-      }
+      if (connector?.backend === "himalaya")
+        return;
       return new GmailSkill({
         ...common(config, workspaceRoot),
         skillName: registrationName,
@@ -8375,15 +8128,15 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   closeSync,
   lstatSync,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync6,
   openSync,
   readdirSync,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync6,
   rmdirSync,
   unlinkSync,
   writeSync
 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join9 } from "node:path";
 function hasErrorCode(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
@@ -8427,7 +8180,7 @@ function inspectRegularFile(path) {
     return { kind: "other" };
   let contents;
   try {
-    contents = readFileSync7(path, "utf8");
+    contents = readFileSync6(path, "utf8");
   } catch (error) {
     if (hasErrorCode(error, "ENOENT"))
       return { kind: "missing" };
@@ -8532,7 +8285,7 @@ function reapStaleLockDirectory(lockPath, staleMs) {
     return removeEmptyLockDirectory(lockPath);
   const staleSnapshots = [];
   for (const name of names) {
-    const inspection = inspectRegularFile(join10(lockPath, name));
+    const inspection = inspectRegularFile(join9(lockPath, name));
     if (inspection.kind === "missing")
       continue;
     if (inspection.kind !== "file" || !isStaleSnapshot(inspection, staleMs))
@@ -8587,14 +8340,14 @@ function createLockFile(lockPath, contents) {
 }
 function tryCreateOwnerMarker(lockPath, owner, contents) {
   try {
-    mkdirSync7(lockPath, { mode: 448 });
+    mkdirSync6(lockPath, { mode: 448 });
   } catch (error) {
     if (hasErrorCode(error, "EEXIST"))
       return;
     throw error;
   }
   const markerName = `owner-${owner.token}.json`;
-  const markerPath = join10(lockPath, markerName);
+  const markerPath = join9(lockPath, markerName);
   let acquired = false;
   try {
     try {
@@ -8680,8 +8433,8 @@ var init_file_lock = __esm(() => {
 
 // src/cli/config.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync8, readFileSync as readFileSync8, renameSync as renameSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename as basename5, dirname as dirname7, isAbsolute as isAbsolute4, join as join11, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync7, renameSync as renameSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute4, join as join10, resolve as resolve5 } from "node:path";
 import { findEnvKeys, getEnvApiKey, getModel, getProviders } from "@earendil-works/pi-ai/compat";
 function resolveConfigPath(input) {
   const flags = input.flags;
@@ -8696,9 +8449,9 @@ function resolveConfigPath(input) {
     return { configPath: envConfig, explicit: true };
   }
   return {
-    configPath: join11(resolveAutoRAGHome(env), DEFAULT_CONFIG_FILENAME),
+    configPath: join10(resolveAutoRAGHome(env), DEFAULT_CONFIG_FILENAME),
     explicit: false,
-    legacyPath: join11(cwd, LEGACY_CONFIG_FILENAME)
+    legacyPath: join10(cwd, LEGACY_CONFIG_FILENAME)
   };
 }
 function readConfigFile(configPath, explicit) {
@@ -8716,7 +8469,7 @@ function readConfigFile(configPath, explicit) {
   }
   let text;
   try {
-    text = readFileSync8(configPath, "utf8");
+    text = readFileSync7(configPath, "utf8");
   } catch (err) {
     throw new ConfigError(`Failed to read config file: ${err.message}`);
   }
@@ -8754,9 +8507,9 @@ function acquireConfigWriteLock(configPath) {
   });
 }
 function replaceFileAtomically(path, contents, assertCommitAllowed) {
-  const temporaryPath = join11(dirname7(path), `.${basename5(path)}.${process.pid}.${randomUUID3()}.tmp`);
+  const temporaryPath = join10(dirname6(path), `.${basename5(path)}.${process.pid}.${randomUUID3()}.tmp`);
   try {
-    writeFileSync6(temporaryPath, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
+    writeFileSync5(temporaryPath, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
     assertCommitAllowed?.();
     renameSync3(temporaryPath, path);
   } finally {
@@ -8767,12 +8520,12 @@ function migrateLegacyConfig(configPath, legacyPath) {
   if (existsSync5(configPath) || !existsSync5(legacyPath))
     return;
   const legacy = readConfigFile(legacyPath, true);
-  const legacyBytes = readFileSync8(legacyPath);
-  const migrated = normalizeLegacyConfigPaths(legacy ?? {}, dirname7(legacyPath));
+  const legacyBytes = readFileSync7(legacyPath);
+  const migrated = normalizeLegacyConfigPaths(legacy ?? {}, dirname6(legacyPath));
   const migratedPathsUnchanged = legacy?.workspacePath === migrated.workspacePath && legacy?.memoryPath === migrated.memoryPath && JSON.stringify(legacy?.searchPaths) === JSON.stringify(migrated.searchPaths);
   const migratedBytes = migratedPathsUnchanged ? legacyBytes : `${JSON.stringify(migrated, null, 2)}
 `;
-  mkdirSync8(dirname7(configPath), { recursive: true });
+  mkdirSync7(dirname6(configPath), { recursive: true });
   const lock = acquireConfigWriteLock(configPath);
   try {
     const winner = readConfigFile(configPath, false);
@@ -8802,7 +8555,7 @@ function resolveConfigFileReadOnly(configPath, explicit, legacyPath) {
   const legacy = readConfigFile(legacyPath, false);
   if (legacy === undefined)
     return {};
-  return normalizeLegacyConfigPaths(legacy, dirname7(legacyPath));
+  return normalizeLegacyConfigPaths(legacy, dirname6(legacyPath));
 }
 function resolveSearchPaths(searchPaths, origin) {
   return searchPaths.map((searchPath) => resolvePersistedPath(searchPath, origin));
@@ -9070,24 +8823,6 @@ function normalizeUiConfig(raw) {
   }
   return out;
 }
-function normalizeBm25Method(raw) {
-  if (raw === false)
-    return { enabled: false };
-  if (raw === undefined || raw === null)
-    return { enabled: true };
-  if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw new ConfigError("bm25 must be an object or false");
-  }
-  const record = raw;
-  for (const key of Object.keys(record)) {
-    if (BM25_LEGACY_IGNORED.has(key))
-      continue;
-    if (!BM25_ALLOWLIST.has(key)) {
-      throw new ConfigError(`bm25.${key} is not a recognized field`);
-    }
-  }
-  return { enabled: record.enabled !== false };
-}
 function normalizeMinSyncMethod(raw) {
   if (raw === false)
     return { enabled: false };
@@ -9098,14 +8833,14 @@ function normalizeMinSyncMethod(raw) {
   }
   const record = raw;
   for (const key of Object.keys(record)) {
+    if (MINSYNC_LEGACY_IGNORED.has(key))
+      continue;
     if (!MINSYNC_ALLOWLIST.has(key)) {
       throw new ConfigError(`minSync.${key} is not a recognized field`);
     }
   }
   const enabled = record.enabled !== false;
   const out = { enabled, autoInstall: record.autoInstall !== false };
-  if (typeof record.binaryPath === "string" && record.binaryPath.length > 0)
-    out.binaryPath = record.binaryPath;
   if (typeof record.workspacePath === "string" && record.workspacePath.length > 0) {
     out.workspacePath = record.workspacePath;
   }
@@ -9128,7 +8863,6 @@ function normalizeMinSyncMethod(raw) {
 }
 function normalizeIndexingConfig(raw) {
   return {
-    bm25: normalizeBm25Method(raw.bm25),
     minSync: normalizeMinSyncMethod(raw.minSync)
   };
 }
@@ -9141,10 +8875,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 = join11(resolveAutoRAGHome(env), "memory.json");
+  const defaultMemoryPath = join10(resolveAutoRAGHome(env), "memory.json");
   const flagSearchPaths = parseCsv(flagString(flags, "search-paths"));
   const envSearchPaths = parseCsv(envString(env, "AUTORAG_SEARCH_PATHS"));
-  const configOrigin = dirname7(resolve5(configPath));
+  const configOrigin = dirname6(resolve5(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;
@@ -9167,10 +8901,8 @@ function resolveConfig(input) {
   if (model)
     config.model = model;
   const normalized = normalizeIndexingConfig({
-    bm25: file.bm25,
     minSync: file.minSync
   });
-  config.bm25 = normalized.bm25;
   config.minSync = normalized.minSync;
   config.jikji = file.jikji === false ? false : file.jikji ?? {};
   if (file.parserOptions)
@@ -9218,12 +8950,6 @@ function buildAgentOptions(config) {
   } else {
     opts.minSync = false;
   }
-  if (config.bm25 && config.bm25.enabled !== false) {
-    const { enabled: _omitBm25Enabled, ...bm25Fields } = config.bm25;
-    opts.bm25 = bm25Fields;
-  } else {
-    opts.bm25 = false;
-  }
   opts.jikji = config.jikji === false ? false : config.jikji ?? {};
   if (config.parserOptions)
     opts.parserOptions = config.parserOptions;
@@ -9448,7 +9174,7 @@ function writeConfigObject(path, config) {
   if (config === null || typeof config !== "object" || Array.isArray(config)) {
     throw new ConfigError("Config file must be a JSON object");
   }
-  mkdirSync8(dirname7(path), { recursive: true });
+  mkdirSync7(dirname6(path), { recursive: true });
   const contents = `${JSON.stringify(config, null, 2)}
 `;
   const lock = acquireConfigWriteLock(path);
@@ -9461,7 +9187,7 @@ function writeConfigObject(path, config) {
 function writeDefaultConfig(path, partial, opts = {}) {
   const cwd = resolve5(opts.cwd ?? process.cwd());
   const workspacePath = resolvePersistedPath(partial.workspacePath ?? ".", cwd);
-  const memoryPath = partial.memoryPath === undefined ? join11(resolveAutoRAGHome(opts.env), "memory.json") : resolvePersistedPath(partial.memoryPath, workspacePath);
+  const memoryPath = partial.memoryPath === undefined ? join10(resolveAutoRAGHome(opts.env), "memory.json") : resolvePersistedPath(partial.memoryPath, workspacePath);
   const full = {
     searchPaths: resolveSearchPaths(partial.searchPaths ?? ["."], cwd),
     workspacePath,
@@ -9470,10 +9196,8 @@ function writeDefaultConfig(path, partial, opts = {}) {
   if (partial.model)
     full.model = partial.model;
   const normalizedMethods = normalizeIndexingConfig({
-    bm25: partial.bm25,
     minSync: partial.minSync
   });
-  full.bm25 = normalizedMethods.bm25;
   full.minSync = normalizedMethods.minSync;
   full.jikji = partial.jikji ?? {};
   full.dupey = partial.dupey ?? { enabled: true };
@@ -9482,7 +9206,7 @@ function writeDefaultConfig(path, partial, opts = {}) {
     full.parserOptions = partial.parserOptions;
   if (partial.ui !== undefined)
     full.ui = normalizeUiConfig(partial.ui);
-  mkdirSync8(dirname7(path), { recursive: true });
+  mkdirSync7(dirname6(path), { recursive: true });
   const contents = `${JSON.stringify(full, null, 2)}
 `;
   const lock = acquireConfigWriteLock(path);
@@ -9494,7 +9218,7 @@ function writeDefaultConfig(path, partial, opts = {}) {
       replaceFileAtomically(path, contents, lock.assertOwned);
     else {
       lock.assertOwned();
-      writeFileSync6(path, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
+      writeFileSync5(path, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
     }
   } catch (error) {
     if (!opts.force && isEexistError(error)) {
@@ -9505,7 +9229,7 @@ function writeDefaultConfig(path, partial, opts = {}) {
     lock.release();
   }
 }
-var DEFAULT_CONFIG_FILENAME = "config.json", LEGACY_CONFIG_FILENAME = "autorag.config.json", CONFIG_LOCK_RETRY_MS = 10, CONFIG_LOCK_TIMEOUT_MS = 1e4, CONFIG_LOCK_STALE_MS = 30000, ConfigError, AGENT_MODEL_APIS, AGENT_MODEL_INPUTS, API_KEY_ENV_PATTERN, POSITIVE_INT_FIELDS, EMBEDDER_ALLOWLIST, BM25_ALLOWLIST, BM25_LEGACY_IGNORED, MINSYNC_ALLOWLIST, UI_TOKEN_ENV_PATTERN;
+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, MINSYNC_ALLOWLIST, MINSYNC_LEGACY_IGNORED, UI_TOKEN_ENV_PATTERN;
 var init_config2 = __esm(() => {
   init_local_model();
   init_home();
@@ -9540,27 +9264,21 @@ var init_config2 = __esm(() => {
     "maxRetries",
     "maxConcurrent"
   ]);
-  BM25_ALLOWLIST = new Set(["enabled"]);
-  BM25_LEGACY_IGNORED = new Set(["indexPath", "fallback", "forceEngine", "importBinding"]);
   MINSYNC_ALLOWLIST = new Set([
     "enabled",
     "autoInstall",
-    "binaryPath",
     "workspacePath",
     "maxChunkSize",
     "installer",
     "embedder"
   ]);
+  MINSYNC_LEGACY_IGNORED = new Set(["binaryPath"]);
   UI_TOKEN_ENV_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 });
 
 // src/cli/commands/init.ts
-var exports_init = {};
-__export(exports_init, {
-  runInit: () => runInit
-});
-import { existsSync as existsSync6, readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname8 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname7 } from "node:path";
 async function runInit(ctx) {
   const flags = ctx.flags;
   const partial = {};
@@ -9617,14 +9335,13 @@ async function runInit(ctx) {
   if (migratingLegacy) {
     try {
       const legacyPath = resolvedPath.legacyPath;
-      const legacy = JSON.parse(readFileSync9(legacyPath, "utf8"));
-      const normalizedLegacy = normalizeLegacyConfigPaths(legacy, dirname8(legacyPath));
+      const legacy = JSON.parse(readFileSync8(legacyPath, "utf8"));
+      const normalizedLegacy = normalizeLegacyConfigPaths(legacy, dirname7(legacyPath));
       partial.searchPaths ??= normalizedLegacy.searchPaths;
       partial.workspacePath ??= normalizedLegacy.workspacePath;
       partial.memoryPath ??= normalizedLegacy.memoryPath;
       partial.model ??= legacy.model;
       partial.minSync ??= legacy.minSync;
-      partial.bm25 ??= legacy.bm25;
       partial.jikji ??= legacy.jikji;
       partial.parserOptions ??= legacy.parserOptions;
       partial.dupey ??= legacy.dupey;
@@ -9806,7 +9523,7 @@ class DatasourceResultFilter {
 }
 
 // src/dupey/cli.ts
-import { spawn as spawn10 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 import { resolve as resolve6 } from "node:path";
 async function scanWithDupey(dir, options = {}) {
   const absoluteDir = resolve6(dir);
@@ -9829,7 +9546,7 @@ function isScanResult(value) {
 }
 function spawnDupey(executable, args, options) {
   return new Promise((resolveOutput, reject) => {
-    const child = spawn10(executable, [...args], {
+    const child = spawn9(executable, [...args], {
       cwd: options.cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -9971,7 +9688,7 @@ var init_diagnostics = __esm(() => {
 
 // src/jikji/answer-pack.ts
 import { realpathSync as realpathSync2 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join12, relative as relative2, resolve as resolve8 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join11, relative as relative2, resolve as resolve8 } from "node:path";
 function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -10100,7 +9817,7 @@ function normalizeJikjiAnswerPath(rawPath, sourceRoots) {
     const rel = relative2(realRoot, realCandidate);
     if (rel.startsWith("..") || isAbsolute5(rel))
       continue;
-    return join12(root.rootPath, rel);
+    return join11(root.rootPath, rel);
   }
   return;
 }
@@ -10114,9 +9831,9 @@ var init_answer_pack = __esm(() => {
 });
 
 // src/jikji/installer.ts
-import { spawn as spawn11 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 import { existsSync as existsSync7 } from "node:fs";
-import { delimiter, join as join13 } from "node:path";
+import { delimiter, join as join12 } from "node:path";
 function jikjiExecutableName(platform = process.platform) {
   return platform === "win32" ? "jikji.exe" : "jikji";
 }
@@ -10124,7 +9841,7 @@ function cargoExecutableName(platform = process.platform) {
   return platform === "win32" ? "cargo.exe" : "cargo";
 }
 function cachedJikjiBinaryPath(root, platform = process.platform) {
-  return join13(root, ".autorag", "bin", jikjiExecutableName(platform));
+  return join12(root, ".autorag", "bin", jikjiExecutableName(platform));
 }
 function lookupExecutableInPath(executable, env) {
   const pathEnv = env.PATH;
@@ -10133,7 +9850,7 @@ function lookupExecutableInPath(executable, env) {
   for (const dir of pathEnv.split(delimiter)) {
     if (dir.length === 0)
       continue;
-    const candidate = join13(dir, executable);
+    const candidate = join12(dir, executable);
     if (existsSync7(candidate))
       return candidate;
   }
@@ -10141,7 +9858,7 @@ function lookupExecutableInPath(executable, env) {
 }
 function defaultRunner(cargo, env) {
   return (args, timeoutMs) => new Promise((resolvePromise) => {
-    const child = spawn11(cargo, args, { env, stdio: ["ignore", "ignore", "pipe"] });
+    const child = spawn10(cargo, args, { env, stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     const timeout = setTimeout(() => {
       if (!child.killed)
@@ -10175,7 +9892,7 @@ 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", join13(options.root, ".autorag")];
+  const args = ["install", JIKJI_CRATE_NAME, "--locked", "--root", join12(options.root, ".autorag")];
   if (options.version !== undefined)
     args.push("--version", options.version);
   const runner = options.runner ?? defaultRunner(cargo, env);
@@ -10195,8 +9912,9 @@ var init_installer = __esm(() => {
 });
 
 // src/jikji/client.ts
-import { spawn as spawn12 } from "node:child_process";
+import { spawn as spawn11 } from "node:child_process";
 import { existsSync as existsSync8 } from "node:fs";
+import { join as join13 } from "node:path";
 
 class JikjiClient {
   options;
@@ -10204,13 +9922,16 @@ class JikjiClient {
   constructor(options = {}) {
     this.options = options;
   }
+  isPrepared(root) {
+    return existsSync8(join13(root, ".jikji", "doc_meta")) || existsSync8(join13(root, ".jikji", "doc_text"));
+  }
   async resolveCommand() {
-    if (this.options.binaryPath !== undefined && this.options.binaryPath !== DEFAULT_BINARY5) {
+    if (this.options.binaryPath !== undefined && this.options.binaryPath !== DEFAULT_BINARY4) {
       return commandFor2(this.options.binaryPath);
     }
     if (this.resolvedCommand !== undefined)
       return this.resolvedCommand;
-    const pathCommand = lookupExecutableInPath(DEFAULT_BINARY5, controlledEnv5(this.options.env));
+    const pathCommand = lookupExecutableInPath(DEFAULT_BINARY4, controlledEnv5(this.options.env));
     if (pathCommand !== undefined) {
       this.resolvedCommand = pathCommand;
       return this.resolvedCommand;
@@ -10229,7 +9950,7 @@ class JikjiClient {
         }
       }
     }
-    this.resolvedCommand = DEFAULT_BINARY5;
+    this.resolvedCommand = DEFAULT_BINARY4;
     return this.resolvedCommand;
   }
   async prepare(root, options = {}) {
@@ -10295,10 +10016,10 @@ class JikjiClient {
   }
 }
 function spawnJikji(request) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve) => {
     const options = request.options;
     const portable = portableSpawnCommand(request.command, request.args);
-    const child = spawn12(portable.command, [...portable.args], {
+    const child = spawn11(portable.command, [...portable.args], {
       env: controlledEnv5(options.env),
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -10310,7 +10031,7 @@ function spawnJikji(request) {
     const timeout = setTimeout(() => {
       finalReason = "timeout";
       terminate7(child);
-    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS8);
+    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS7);
     const abortHandler = () => {
       finalReason = "aborted";
       terminate7(child);
@@ -10340,7 +10061,7 @@ function spawnJikji(request) {
       settled = true;
       clearTimeout(timeout);
       request.signal?.removeEventListener("abort", abortHandler);
-      resolve9({ ok: false, reason: "spawn-error", stdout: stdout.text, stderr: error.message, code: null });
+      resolve({ ok: false, reason: "spawn-error", stdout: stdout.text, stderr: error.message, code: null });
     });
     child.on("close", (code) => {
       if (settled)
@@ -10349,15 +10070,15 @@ function spawnJikji(request) {
       clearTimeout(timeout);
       request.signal?.removeEventListener("abort", abortHandler);
       if (finalReason !== undefined) {
-        resolve9({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
+        resolve({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
         return;
       }
-      resolve9({ ok: code === 0, stdout: stdout.text, stderr: stderr.text, code });
+      resolve({ ok: code === 0, stdout: stdout.text, stderr: stderr.text, code });
     });
   });
 }
 function commandFor2(binaryPath) {
-  return binaryPath === undefined || binaryPath === DEFAULT_BINARY5 ? DEFAULT_BINARY5 : binaryPath;
+  return binaryPath === undefined || binaryPath === DEFAULT_BINARY4 ? DEFAULT_BINARY4 : binaryPath;
 }
 function buildPrepareArgs(options, root) {
   const args = ["prepare", root, "--json"];
@@ -10424,7 +10145,7 @@ function appendBounded5(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_BINARY5 = "jikji", DEFAULT_TIMEOUT_MS8 = 1e4, DEFAULT_MAX_BUFFER_BYTES4 = 1048576;
+var DEFAULT_BINARY4 = "jikji", DEFAULT_TIMEOUT_MS7 = 1e4, DEFAULT_MAX_BUFFER_BYTES4 = 1048576;
 var init_client6 = __esm(() => {
   init_portable_spawn();
   init_answer_pack();
@@ -10493,7 +10214,7 @@ var init_jikji = __esm(() => {
 });
 
 // src/manifest/loader.ts
-import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync9 } from "node:fs";
 import { extname as extname7, join as join14 } from "node:path";
 import { parse as parseYaml } from "yaml";
 function isValidManifest(data) {
@@ -10503,7 +10224,7 @@ 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 loadManifest2(filePath) {
-  const content = readFileSync10(filePath, "utf-8");
+  const content = readFileSync9(filePath, "utf-8");
   const ext = extname7(filePath).toLowerCase();
   let data;
   if (ext === ".yaml" || ext === ".yml") {
@@ -10700,8 +10421,8 @@ var init_evidence_id = () => {};
 
 // src/memory/memory.ts
 import { createHash as createHash5, randomUUID as randomUUID4 } from "node:crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync9, readFileSync as readFileSync11, renameSync as renameSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync10, renameSync as renameSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname8 } from "node:path";
 function emptyMemoryV4() {
   return {
     version: 4,
@@ -10830,8 +10551,8 @@ function migrateV3(data) {
 function hashText(value) {
   return createHash5("sha256").update(value).digest("hex");
 }
-function resultId(sessionId, number2) {
-  return `${sessionId}:${number2}`;
+function resultId(sessionId, number) {
+  return `${sessionId}:${number}`;
 }
 function resultHash(query, title, summary, evidenceIds) {
   return hashText([query, title, summary, ...evidenceIds].join("\x00"));
@@ -10938,9 +10659,9 @@ class RetrievalMemory {
     this.persistedData = cloneMemory(this.data);
   }
   save() {
-    const dir = dirname9(this.storagePath);
+    const dir = dirname8(this.storagePath);
     if (!existsSync10(dir))
-      mkdirSync9(dir, { recursive: true });
+      mkdirSync8(dir, { recursive: true });
     const lock = this.acquireLock();
     const localData = this.data;
     let tmpPath;
@@ -10948,7 +10669,7 @@ class RetrievalMemory {
       this.data = this.mergeWithPersisted(this.readPersistedData());
       this.capData();
       tmpPath = `${this.storagePath}.${randomUUID4()}.tmp`;
-      writeFileSync7(tmpPath, `${JSON.stringify(this.data, null, 2)}
+      writeFileSync6(tmpPath, `${JSON.stringify(this.data, null, 2)}
 `, "utf-8");
       lock.assertOwned();
       renameSync4(tmpPath, this.storagePath);
@@ -11026,11 +10747,11 @@ class RetrievalMemory {
         timestamp: Date.now()
       });
       const evidenceWeight = curated.evidenceIds.length > 0 ? explicitWeight / curated.evidenceIds.length : 0;
-      for (const stableEvidenceId2 of curated.evidenceIds) {
-        const evidence = this.data.evidenceChunks.find((chunk) => chunk.stableEvidenceId === stableEvidenceId2);
+      for (const stableEvidenceId of curated.evidenceIds) {
+        const evidence = this.data.evidenceChunks.find((chunk) => chunk.stableEvidenceId === stableEvidenceId);
         this.data.feedbackSignals.push({
           id: randomUUID4(),
-          target: { type: "evidence_chunk", stableEvidenceId: stableEvidenceId2 },
+          target: { type: "evidence_chunk", stableEvidenceId },
           query: curated.query,
           method: evidence?.method,
           sentiment,
@@ -11116,8 +10837,8 @@ class RetrievalMemory {
     for (const signal of this.data.feedbackSignals) {
       if (signal.target.type !== "evidence_chunk")
         continue;
-      const stableEvidenceId2 = signal.target.stableEvidenceId;
-      const evidence = this.data.evidenceChunks.find((chunk) => chunk.stableEvidenceId === stableEvidenceId2);
+      const stableEvidenceId = signal.target.stableEvidenceId;
+      const evidence = this.data.evidenceChunks.find((chunk) => chunk.stableEvidenceId === stableEvidenceId);
       if (!evidence)
         continue;
       add(documentAreas, evidence.documentArea, signal);
@@ -11214,7 +10935,7 @@ class RetrievalMemory {
     if (!existsSync10(this.storagePath))
       return emptyMemoryV4();
     try {
-      const parsed = JSON.parse(readFileSync11(this.storagePath, "utf-8"));
+      const parsed = JSON.parse(readFileSync10(this.storagePath, "utf-8"));
       if (isV4(parsed))
         return normalizeV4(parsed);
       if (isV3(parsed))
@@ -11478,7 +11199,7 @@ var init_memory = __esm(() => {
 });
 
 // src/minsync/embedder-config.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
 import { join as join15 } from "node:path";
 import { parse as parse3, stringify } from "smol-toml";
 function minSyncConfigPath(workspacePath) {
@@ -11487,7 +11208,7 @@ function minSyncConfigPath(workspacePath) {
 function configuredMaxChunkSize(workspacePath) {
   let raw;
   try {
-    raw = readFileSync12(minSyncConfigPath(workspacePath), "utf8");
+    raw = readFileSync11(minSyncConfigPath(workspacePath), "utf8");
   } catch {
     return;
   }
@@ -11505,7 +11226,7 @@ function rewriteEmbedderConfig(workspacePath, embedder, chunkerConfig = {}) {
   const configPath = minSyncConfigPath(workspacePath);
   let raw;
   try {
-    raw = readFileSync12(configPath, "utf8");
+    raw = readFileSync11(configPath, "utf8");
   } catch {
     return false;
   }
@@ -11541,18 +11262,18 @@ function rewriteEmbedderConfig(workspacePath, embedder, chunkerConfig = {}) {
     options.dimension = embedder.dimension;
   if (chunkerConfig.maxChunkSize !== undefined)
     chunkerOptions.max_chunk_size = chunkerConfig.maxChunkSize;
-  writeFileSync8(configPath, stringify(parsed));
+  writeFileSync7(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 spawn13 } from "node:child_process";
+import { spawn as spawn12 } from "node:child_process";
 function spawnProcess(command, args, cwd, options = {}) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve) => {
     const portable = portableSpawnCommand(command, args);
-    const child = spawn13(portable.command, [...portable.args], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn12(portable.command, [...portable.args], { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     let timedOut = false;
@@ -11571,15 +11292,15 @@ function spawnProcess(command, args, cwd, options = {}) {
     child.on("error", (error) => {
       if (timer)
         clearTimeout(timer);
-      resolve10({ ok: false, stdout, stderr: error.message, code: null });
+      resolve({ ok: false, stdout, stderr: error.message, code: null });
     });
     child.on("close", (code) => {
       if (timer)
         clearTimeout(timer);
       if (timedOut) {
-        resolve10({ ok: false, stdout, stderr: "process timed out", code: null, timedOut: true });
+        resolve({ ok: false, stdout, stderr: "process timed out", code: null, timedOut: true });
       } else {
-        resolve10({ ok: code === 0, stdout, stderr, code });
+        resolve({ ok: code === 0, stdout, stderr, code });
       }
     });
   });
@@ -11589,7 +11310,7 @@ var init_process = __esm(() => {
 });
 
 // src/minsync/client.ts
-import { existsSync as existsSync11, readFileSync as readFileSync13, rmSync as rmSync2, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync12, rmSync as rmSync2, writeFileSync as writeFileSync8 } from "node:fs";
 import { join as join16 } from "node:path";
 
 class MinSyncClient {
@@ -11647,7 +11368,7 @@ class MinSyncClient {
     const configRewritten = shouldRewriteConfig && rewriteEmbedderConfig(this.workspacePath, this.embedder ?? {}, { maxChunkSize: this.maxChunkSize });
     const restoreConfig = () => {
       if (configRewritten && originalConfig !== undefined)
-        writeFileSync9(configPath, originalConfig);
+        writeFileSync8(configPath, originalConfig);
     };
     const check = await this.spawn(["check", "--format", "json"], spawnOpts);
     if (!check.ok) {
@@ -11702,7 +11423,7 @@ class MinSyncClient {
 }
 function readConfigSnapshot(configPath) {
   try {
-    return readFileSync13(configPath, "utf8");
+    return readFileSync12(configPath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -11765,11 +11486,11 @@ var init_client7 = __esm(() => {
 
 // src/minsync/installer.ts
 import { createHash as createHash6 } from "node:crypto";
-import { copyFileSync, createWriteStream, existsSync as existsSync12, mkdirSync as mkdirSync10, renameSync as renameSync5, rmSync as rmSync3 } from "node:fs";
+import { copyFileSync, createWriteStream, existsSync as existsSync12, mkdirSync as mkdirSync9, renameSync as renameSync5, rmSync as rmSync3 } from "node:fs";
 import { chmod, mkdtemp as mkdtemp2 } from "node:fs/promises";
 import { get } from "node:https";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename6, dirname as dirname10, join as join17 } from "node:path";
+import { basename as basename6, dirname as dirname9, join as join17 } from "node:path";
 import { pipeline } from "node:stream/promises";
 async function ensureMinSyncBinary(options) {
   const binaryPath = join17(options.root, ".autorag", "bin", executableName(options.platform ?? process.platform));
@@ -11787,15 +11508,15 @@ async function ensureMinSyncBinary(options) {
   }
   requireSha256(asset);
   const assetInstaller = options.assetInstaller ?? installReleaseAsset;
-  mkdirSync10(dirname10(binaryPath), { recursive: true });
+  mkdirSync9(dirname9(binaryPath), { recursive: true });
   await assetInstaller(asset, binaryPath);
   await chmod(binaryPath, 493);
   return { binaryPath, version: release.tagName };
 }
 async function installMinSyncFromCargo(options, destination) {
   const cargoRoot = join17(options.root, ".autorag", "minsync-cargo");
-  mkdirSync10(dirname10(destination), { recursive: true });
-  mkdirSync10(cargoRoot, { recursive: true });
+  mkdirSync9(dirname9(destination), { recursive: true });
+  mkdirSync9(cargoRoot, { recursive: true });
   const result = await spawnProcess("cargo", ["install", "minsync", "--version", MINSYNC_VERSION, "--locked", "--root", cargoRoot], options.root);
   if (!result.ok) {
     throw new MinSyncReleaseError(result.stderr || `Could not install MinSync ${MINSYNC_VERSION} from crates.io`);
@@ -11859,11 +11580,11 @@ async function verifySha256(path, expected) {
     throw new MinSyncReleaseError(`MinSync asset sha256 mismatch: expected ${expected}, got ${actual}`);
 }
 function readHttpsText(url, redirectCount = 0) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve, reject) => {
     get(url, { headers: { "User-Agent": "AutoRAG-MinSync" } }, (response) => {
       if (isRedirect(response.statusCode) && response.headers.location) {
         response.resume();
-        readHttpsText(new URL(response.headers.location, url).toString(), redirectCount + 1).then(resolve10, reject);
+        readHttpsText(new URL(response.headers.location, url).toString(), redirectCount + 1).then(resolve, reject);
         return;
       }
       if (redirectCount > 5) {
@@ -11882,17 +11603,17 @@ function readHttpsText(url, redirectCount = 0) {
         body += chunk;
       });
       response.on("end", () => {
-        resolve10(body);
+        resolve(body);
       });
     }).on("error", reject);
   });
 }
 function openHttps(url, redirectCount = 0) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve, reject) => {
     get(url, { headers: { "User-Agent": "AutoRAG-MinSync" } }, (response) => {
       if (isRedirect(response.statusCode) && response.headers.location) {
         response.resume();
-        openHttps(new URL(response.headers.location, url).toString(), redirectCount + 1).then(resolve10, reject);
+        openHttps(new URL(response.headers.location, url).toString(), redirectCount + 1).then(resolve, reject);
         return;
       }
       if (redirectCount > 5) {
@@ -11905,7 +11626,7 @@ function openHttps(url, redirectCount = 0) {
         response.resume();
         return;
       }
-      resolve10(response);
+      resolve(response);
     }).on("error", reject);
   });
 }
@@ -11952,61 +11673,39 @@ var init_installer2 = __esm(() => {
   };
 });
 
-// src/retrieval/methods/bm25.ts
-import { existsSync as existsSync13, rmSync as rmSync4 } from "node:fs";
-import { join as join18 } from "node:path";
-function removeLegacyBm25Artifacts(root) {
-  rmSync4(join18(root, BM25_SUBDIR), { recursive: true, force: true });
-}
-function hasLegacyBm25Artifacts(root) {
-  return existsSync13(join18(root, BM25_SUBDIR));
-}
-var BM25_SUBDIR, BM25UnavailableError;
-var init_bm25 = __esm(() => {
-  BM25_SUBDIR = join18(".autorag", "bm25");
-  BM25UnavailableError = class BM25UnavailableError extends Error {
-    readiness;
-    constructor(readiness, message) {
-      super(message);
-      this.name = "BM25UnavailableError";
-      this.readiness = readiness;
-    }
-  };
-});
-
 // src/minsync/paths.ts
-import { join as join19 } from "node:path";
+import { join as join18 } from "node:path";
 function minSyncWorkspaceRoot(root) {
-  return join19(root, MINSYNC_SUBDIR);
+  return join18(root, MINSYNC_SUBDIR);
 }
 function minSyncDocumentPath(workspacePath, virtualPath) {
   const safePath = virtualPath.replace(/^\/+/, "");
-  return join19(workspacePath, MINSYNC_FILES_SUBDIR, `${safePath}.md`);
+  return join18(workspacePath, MINSYNC_FILES_SUBDIR, `${safePath}.md`);
 }
 var MINSYNC_SUBDIR, MINSYNC_FILES_SUBDIR = "files";
 var init_paths4 = __esm(() => {
-  MINSYNC_SUBDIR = join19(".autorag", "minsync");
+  MINSYNC_SUBDIR = join18(".autorag", "minsync");
 });
 
 // src/minsync/workspace.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync14,
+  existsSync as existsSync13,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync11,
+  mkdirSync as mkdirSync10,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync13,
   renameSync as renameSync6,
-  rmSync as rmSync5,
-  writeFileSync as writeFileSync10
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync9
 } from "node:fs";
-import { basename as basename7, dirname as dirname11, isAbsolute as isAbsolute7, join as join20, relative as relative4, sep as sep3 } from "node:path";
+import { basename as basename7, dirname as dirname10, isAbsolute as isAbsolute7, join as join19, relative as relative4, sep as sep3 } from "node:path";
 function syncMinSyncWorkspace(root, options = {}) {
   const workspacePath = options.workspacePath ?? minSyncWorkspaceRoot(root);
-  const filesRoot = join20(workspacePath, "files");
+  const filesRoot = join19(workspacePath, "files");
   const index = loadMirrorIndex(root);
-  const entries = Object.values(index.entries).sort((a, b) => a.virtualPath.localeCompare(b.virtualPath)).filter((entry) => normalizeVirtualPath(entry.virtualPath) === entry.virtualPath && existsSync14(entry.outputPath)).map((entry) => {
+  const entries = Object.values(index.entries).sort((a, b) => a.virtualPath.localeCompare(b.virtualPath)).filter((entry) => normalizeVirtualPath(entry.virtualPath) === entry.virtualPath && existsSync13(entry.outputPath)).map((entry) => {
     const minSyncPath = minSyncDocumentPath(workspacePath, entry.virtualPath);
     return {
       virtualPath: entry.virtualPath,
@@ -12026,7 +11725,7 @@ function syncMinSyncWorkspace(root, options = {}) {
     const previousEntry = previousState?.entries[entry.virtualPath];
     const unchanged = previousEntry?.outputPath === mirrorEntry.outputPath && previousEntry.updatedAt === mirrorEntry.updatedAt && isRegularFile(entry.minSyncPath);
     if (!unchanged) {
-      ensureManagedDirectory(filesRoot, dirname11(entry.minSyncPath));
+      ensureManagedDirectory(filesRoot, dirname10(entry.minSyncPath));
       copyFileAtomically(entry.parsedOutputPath, entry.minSyncPath);
     }
     currentState[entry.virtualPath] = {
@@ -12040,14 +11739,14 @@ function syncMinSyncWorkspace(root, options = {}) {
   return { workspacePath, entries };
 }
 function stagingStatePath(workspacePath) {
-  return join20(dirname11(workspacePath), `.${basename7(workspacePath)}-autorag-staging.json`);
+  return join19(dirname10(workspacePath), `.${basename7(workspacePath)}-autorag-staging.json`);
 }
 function loadStagingState(workspacePath) {
   const path = stagingStatePath(workspacePath);
   if (!isRegularFile(path))
     return;
   try {
-    const parsed = JSON.parse(readFileSync14(path, "utf8"));
+    const parsed = JSON.parse(readFileSync13(path, "utf8"));
     return isMinSyncStagingState(parsed) ? parsed : undefined;
   } catch {
     return;
@@ -12056,7 +11755,7 @@ function loadStagingState(workspacePath) {
 function saveStagingState(workspacePath, state) {
   const path = stagingStatePath(workspacePath);
   const temporaryPath = `${path}.${randomUUID5()}.tmp`;
-  writeFileSync10(temporaryPath, `${JSON.stringify(state, null, 2)}
+  writeFileSync9(temporaryPath, `${JSON.stringify(state, null, 2)}
 `);
   renameSync6(temporaryPath, path);
 }
@@ -12068,9 +11767,9 @@ function isMinSyncStagingState(value) {
 function ensureManagedFilesRoot(filesRoot, rebuild) {
   const status = lstatSync2(filesRoot, { throwIfNoEntry: false });
   if (status !== undefined && (rebuild || !status.isDirectory())) {
-    rmSync5(filesRoot, { recursive: status.isDirectory(), force: true });
+    rmSync4(filesRoot, { recursive: status.isDirectory(), force: true });
   }
-  mkdirSync11(filesRoot, { recursive: true });
+  mkdirSync10(filesRoot, { recursive: true });
 }
 function ensureManagedDirectory(filesRoot, directory) {
   const relativeDirectory = relative4(filesRoot, directory);
@@ -12080,23 +11779,23 @@ function ensureManagedDirectory(filesRoot, directory) {
   const segments = relativeDirectory.split(sep3).filter(Boolean);
   let current = filesRoot;
   for (const segment of segments) {
-    current = join20(current, segment);
+    current = join19(current, segment);
     const status = lstatSync2(current, { throwIfNoEntry: false });
     if (status?.isDirectory())
       continue;
     if (status !== undefined) {
-      rmSync5(current, { force: true });
+      rmSync4(current, { force: true });
     }
-    mkdirSync11(current);
+    mkdirSync10(current);
   }
 }
 function copyFileAtomically(source, destination) {
-  const temporaryPath = join20(dirname11(destination), `.${basename7(destination)}.${randomUUID5()}.tmp`);
+  const temporaryPath = join19(dirname10(destination), `.${basename7(destination)}.${randomUUID5()}.tmp`);
   try {
     copyFileSync2(source, temporaryPath);
     renameSync6(temporaryPath, destination);
   } finally {
-    rmSync5(temporaryPath, { force: true });
+    rmSync4(temporaryPath, { force: true });
   }
 }
 function isRegularFile(path) {
@@ -12104,11 +11803,11 @@ function isRegularFile(path) {
 }
 function removeUnexpectedStagedFiles(directory, desiredPaths) {
   for (const entry of readdirSync3(directory, { withFileTypes: true })) {
-    const path = join20(directory, entry.name);
+    const path = join19(directory, entry.name);
     if (entry.isDirectory()) {
       removeUnexpectedStagedFiles(path, desiredPaths);
     } else if (!desiredPaths.has(path)) {
-      rmSync5(path, { force: true });
+      rmSync4(path, { force: true });
     }
   }
 }
@@ -12134,7 +11833,7 @@ function buildMinSyncPathMap(root, workspacePath) {
   return byPath;
 }
 function legacyParsedVirtualPath(root, virtualPath) {
-  return join20(root, ".autorag", "parsed", "files", `${virtualPath.replace(/^\/+/, "")}.md`);
+  return join19(root, ".autorag", "parsed", "files", `${virtualPath.replace(/^\/+/, "")}.md`);
 }
 var init_workspace = __esm(() => {
   init_source_paths();
@@ -12143,8 +11842,8 @@ var init_workspace = __esm(() => {
 });
 
 // src/minsync/method.ts
-import { accessSync, constants, existsSync as existsSync15, realpathSync as realpathSync3 } from "node:fs";
-import { basename as basename8, delimiter as delimiter2, join as join21, normalize as normalize2 } from "node:path";
+import { accessSync, constants, existsSync as existsSync14, realpathSync as realpathSync3 } from "node:fs";
+import { basename as basename8, delimiter as delimiter2, join as join20, normalize as normalize2 } from "node:path";
 function degrade(workspacePath, reason) {
   return { ok: false, synced: 0, workspacePath, reason };
 }
@@ -12156,7 +11855,7 @@ function lookupInPath(env) {
   for (const dir of pathEnv.split(delimiter2)) {
     if (dir.length === 0)
       continue;
-    const candidate = join21(dir, execName);
+    const candidate = join20(dir, execName);
     try {
       accessSync(candidate, constants.X_OK);
       return candidate;
@@ -12216,7 +11915,10 @@ class MinSyncVectorMethod {
     return binaryResult;
   }
   isBinaryMissing() {
-    return this.binaryPath !== undefined && !existsSync15(this.binaryPath);
+    return this.binaryPath !== undefined && !existsSync14(this.binaryPath);
+  }
+  isReady() {
+    return existsSync14(join20(this.workspacePath, ".minsync", "cursor.json"));
   }
   async retrieve(query, options) {
     const topK = options.topK ?? 20;
@@ -12256,16 +11958,15 @@ class MinSyncVectorMethod {
     return results;
   }
   async resolveBinary() {
-    if (this.binaryPath && existsSync15(this.binaryPath)) {
+    if (this.binaryPath && existsSync14(this.binaryPath))
       return this.binaryPath;
-    }
     if (this.binaryPath !== undefined)
       return;
     const pathBinary = lookupInPath(process.env);
     if (pathBinary)
       return pathBinary;
-    const cachedBinary = join21(this.root, ".autorag", "bin", executableName(process.platform));
-    if (existsSync15(cachedBinary))
+    const cachedBinary = join20(this.root, ".autorag", "bin", executableName(process.platform));
+    if (existsSync14(cachedBinary))
       return cachedBinary;
     if (this.autoInstall) {
       try {
@@ -12278,63 +11979,13 @@ class MinSyncVectorMethod {
     return;
   }
 }
-var MinSyncBM25Method, MinSyncHybridMethod;
+var MinSyncHybridMethod;
 var init_method = __esm(() => {
-  init_bm25();
   init_scope();
   init_client7();
   init_installer2();
   init_paths4();
   init_workspace();
-  MinSyncBM25Method = class MinSyncBM25Method extends MinSyncVectorMethod {
-    status = { readiness: "index_missing", engine: "minsync" };
-    constructor(options) {
-      super({ ...options, mode: "bm25" });
-    }
-    describe() {
-      return {
-        name: "bm25",
-        type: "bm25",
-        description: "MinSync-backed BM25 lexical retrieval over parsed markdown mirror chunks",
-        status: this.status.readiness === "ready" ? "active" : "stub",
-        capabilities: [
-          "lexical",
-          "incremental",
-          "parsed-mirrors",
-          "virtual-paths",
-          `readiness:${this.status.readiness}`
-        ]
-      };
-    }
-    async retrieve(query, options) {
-      const binaryResult = await this.resolveBinaryForRetrieve();
-      if (binaryResult === undefined) {
-        const readiness = this.status.readiness === "ready" ? "dependency_unavailable" : this.status.readiness;
-        throw new BM25UnavailableError(readiness === "index_missing" ? "dependency_unavailable" : readiness, this.status.message ?? "MinSync BM25 is unavailable");
-      }
-      return super.retrieve(query, options);
-    }
-    syncFromMinSync(result) {
-      this.status = result.ok ? { readiness: "ready", engine: "minsync" } : {
-        readiness: result.reason === "missing-binary" ? "dependency_unavailable" : "error",
-        engine: "minsync",
-        message: result.reason
-      };
-      return {
-        indexPath: result.workspacePath,
-        indexedChunks: result.synced,
-        readiness: this.status.readiness,
-        engine: this.status.engine
-      };
-    }
-    getStatus() {
-      return this.status;
-    }
-    async resolveBinaryForRetrieve() {
-      const binaryResult = await this.resolveBinary();
-      return typeof binaryResult === "string" ? binaryResult : undefined;
-    }
-  };
   MinSyncHybridMethod = class MinSyncHybridMethod extends MinSyncVectorMethod {
     constructor(options) {
       super({ ...options, mode: "hybrid" });
@@ -12363,14 +12014,14 @@ var init_minsync = __esm(() => {
 
 // src/mirror/sync.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { existsSync as existsSync16, mkdirSync as mkdirSync12, renameSync as renameSync7, rmSync as rmSync6, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync11, renameSync as renameSync7, rmSync as rmSync5, writeFileSync as writeFileSync10 } from "node:fs";
 import { opendir, readFile as readFile5, stat as stat4 } from "node:fs/promises";
-import { dirname as dirname12, extname as extname8, resolve as resolve10 } from "node:path";
-function parserFailureCode(parser2, error) {
-  return parser2.name === "opendataloader-pdf" && /UnsupportedClassVersionError/.test(error.message) ? "pdf-java-version" : "parser-failed";
+import { dirname as dirname11, extname as extname8, resolve as resolve10 } from "node:path";
+function parserFailureCode(parser, error) {
+  return parser.name === "opendataloader-pdf" && /UnsupportedClassVersionError/.test(error.message) ? "pdf-java-version" : "parser-failed";
 }
-function parserFailureMessage(parser2, error) {
-  if (parserFailureCode(parser2, error) === "pdf-java-version") {
+function parserFailureMessage(parser, error) {
+  if (parserFailureCode(parser, error) === "pdf-java-version") {
     return "PDF parsing requires Java 11 or newer; the Java runtime selected from PATH is too old.";
   }
   return "The registered parser failed on this file; it was skipped during indexing.";
@@ -12410,8 +12061,8 @@ async function syncParsedMirrors(options) {
       });
       continue;
     }
-    const parser2 = registry.getForVirtualPath(entry.virtualPath);
-    if (!parser2) {
+    const parser = registry.getForVirtualPath(entry.virtualPath);
+    if (!parser) {
       deleted += removePrevious(options.root, previous, entry.virtualPath);
       handledPrevious.add(entry.virtualPath);
       skipped += 1;
@@ -12434,12 +12085,12 @@ 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 && existsSync16(outputPath);
+    const unchanged = !options.force && previousEntry?.sourceMtimeNs === entry.mtimeNs && previousEntry.sourceSizeBytes === entry.sizeBytes && previousEntry.parserName === parser.name && existsSync15(outputPath);
     if (!unchanged) {
       let parsed;
       try {
         const bytes = await readFile5(entry.sourcePath);
-        parsed = await parser2.parse({ virtualPath: entry.virtualPath, sourcePath: entry.sourcePath, bytes });
+        parsed = await parser.parse({ virtualPath: entry.virtualPath, sourcePath: entry.sourcePath, bytes });
       } catch (error) {
         if (!(error instanceof ParseError))
           throw error;
@@ -12447,9 +12098,9 @@ async function syncParsedMirrors(options) {
         handledPrevious.add(entry.virtualPath);
         skipped += 1;
         diagnostics.push({
-          code: parserFailureCode(parser2, error),
+          code: parserFailureCode(parser, error),
           severity: "warning",
-          message: parserFailureMessage(parser2, error),
+          message: parserFailureMessage(parser, error),
           source: entry.virtualPath
         });
         sinceCheckpoint += 1;
@@ -12473,7 +12124,7 @@ async function syncParsedMirrors(options) {
       virtualPath: entry.virtualPath,
       sourcePath: entry.sourcePath,
       outputPath,
-      parserName: parser2.name,
+      parserName: parser.name,
       sourceMtimeNs: entry.mtimeNs,
       sourceSizeBytes: entry.sizeBytes,
       updatedAt: unchanged ? previousEntry?.updatedAt ?? new Date().toISOString() : new Date().toISOString()
@@ -12532,8 +12183,8 @@ async function detectMirrorStaleness(options) {
 }
 function supportedExtensionSet(registry) {
   const extensions = new Set;
-  for (const parser2 of registry.list()) {
-    for (const extension of parser2.extensions) {
+  for (const parser of registry.list()) {
+    for (const extension of parser.extensions) {
       extensions.add(normalizeExtension2(extension));
     }
   }
@@ -12593,14 +12244,14 @@ function removePrevious(root, index, virtualPath) {
   return 1;
 }
 function writeAtomic(path, content) {
-  mkdirSync12(dirname12(path), { recursive: true });
+  mkdirSync11(dirname11(path), { recursive: true });
   const tmp = `${path}.${randomUUID6()}.tmp`;
-  writeFileSync11(tmp, content);
+  writeFileSync10(tmp, content);
   renameSync7(tmp, path);
 }
 function removeFile(path) {
-  if (existsSync16(path))
-    rmSync6(path, { force: true });
+  if (existsSync15(path))
+    rmSync5(path, { force: true });
 }
 var DEFAULT_MAX_SOURCE_BYTES, MIRROR_CHECKPOINT_EVERY = 25, SKIP_DIR_NAMES;
 var init_sync = __esm(() => {
@@ -12636,8 +12287,8 @@ var init_sync = __esm(() => {
 });
 
 // src/observability/run-log.ts
-import { appendFileSync, mkdirSync as mkdirSync13 } from "node:fs";
-import { dirname as dirname13 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync12 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
 
 class AutoRAGRunLogger {
   path;
@@ -12646,7 +12297,7 @@ class AutoRAGRunLogger {
   }
   write(event) {
     try {
-      mkdirSync13(dirname13(this.path), { recursive: true });
+      mkdirSync12(dirname12(this.path), { recursive: true });
       appendFileSync(this.path, `${JSON.stringify(event)}
 `, "utf8");
     } catch (error) {}
@@ -12768,8 +12419,6 @@ class ParallelRetriever {
 function methodFailureCode(name) {
   if (name === "minsync")
     return "minsync-unavailable";
-  if (name === "bm25")
-    return "bm25-unavailable";
   return "retrieval-method-failed";
 }
 var MAX_AGGREGATION_BONUS = 0.3, MAX_SECONDARY_HITS = 3, SECONDARY_HIT_WEIGHT = 0.15;
@@ -12798,7 +12447,7 @@ class RetrievalMethodRegistry {
 // src/filesystem/cloud-placeholder.ts
 import { execFile } from "node:child_process";
 import { lstat } from "node:fs/promises";
-import { dirname as dirname14, relative as relative5, sep as sep4 } from "node:path";
+import { dirname as dirname13, relative as relative5, sep as sep4 } from "node:path";
 import { promisify } from "node:util";
 function pathLooksLikeCloudRoot(target) {
   const normalized = target.replaceAll("\\", "/");
@@ -12836,7 +12485,7 @@ async function classifyDarwinRoot(target) {
     const provider = await readFileProviderDomain(cursor);
     if (provider !== undefined)
       return { kind: "file-provider", reason: "file-provider-xattr", provider };
-    const parent = dirname14(cursor);
+    const parent = dirname13(cursor);
     if (parent === cursor)
       break;
     cursor = parent;
@@ -12921,12 +12570,12 @@ var init_cloud_placeholder = __esm(() => {
 });
 
 // src/agent/bash-tool.ts
-import { spawn as spawn14 } from "node:child_process";
+import { spawn as spawn13 } from "node:child_process";
 import { Type as Type2 } from "typebox";
 function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve) => {
     if (signal?.aborted) {
-      resolve11({
+      resolve({
         output: "",
         exitCode: undefined,
         aborted: true,
@@ -12937,7 +12586,7 @@ function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
       return;
     }
     const shell = process.platform === "win32" ? "bash.exe" : "/bin/bash";
-    const child = spawn14(shell, ["-c", command], {
+    const child = spawn13(shell, ["-c", command], {
       cwd,
       detached: process.platform !== "win32",
       windowsHide: true
@@ -12983,7 +12632,7 @@ function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
       if (killGraceTimer !== undefined)
         clearTimeout(killGraceTimer);
       signal?.removeEventListener("abort", onAbort);
-      resolve11({
+      resolve({
         output: Buffer.concat(chunks).toString("utf8"),
         exitCode,
         aborted,
@@ -13003,15 +12652,15 @@ function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
       if (child.pid === undefined)
         return true;
       if (process.platform === "win32") {
-        return await new Promise((resolve12) => {
-          const killer = spawn14("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
+        return await new Promise((resolve) => {
+          const killer = spawn13("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
           let completed = false;
           const graceTimer = setTimeout(() => {
             if (completed)
               return;
             completed = true;
             killer.kill();
-            resolve12(killDirectChild());
+            resolve(killDirectChild());
           }, KILL_EXIT_GRACE_MS);
           const finishKill = (success) => {
             if (completed)
@@ -13020,7 +12669,7 @@ function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
             clearTimeout(graceTimer);
             if (!success)
               killDirectChild();
-            resolve12(success);
+            resolve(success);
           };
           killer.on("error", () => finishKill(false));
           killer.on("close", (code) => finishKill(code === 0));
@@ -13068,7 +12717,7 @@ function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
   });
 }
 function createBashTool(options) {
-  const defaultTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS9;
+  const defaultTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS8;
   const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
   return {
     name: BASH_TOOL_NAME,
@@ -13165,7 +12814,7 @@ function createBashTool(options) {
     }
   };
 }
-var BASH_TOOL_NAME = "bash", DEFAULT_TIMEOUT_MS9 = 120000, DEFAULT_MAX_OUTPUT_BYTES = 131072, KILL_EXIT_GRACE_MS = 5000, bashSchema, CLOUD_CONTENT_COMMAND;
+var BASH_TOOL_NAME = "bash", DEFAULT_TIMEOUT_MS8 = 120000, DEFAULT_MAX_OUTPUT_BYTES = 131072, KILL_EXIT_GRACE_MS = 5000, bashSchema, CLOUD_CONTENT_COMMAND;
 var init_bash_tool = __esm(() => {
   init_cloud_placeholder();
   bashSchema = Type2.Object({
@@ -13499,7 +13148,7 @@ function createSearchAllDocumentsTool(provider) {
   return {
     name: SEARCH_ALL_DOCUMENTS_TOOL_NAME,
     label: "Search All Documents",
-    description: "Search across all configured retrieval methods (posix, BM25, MinSync, datasources) and return merged, deduplicated results. Authority is server-configured; tool arguments can only provide query, topK, and an optional narrowing scope.",
+    description: "Search across all configured retrieval methods (posix, MinSync, datasources) and return merged, deduplicated results. Authority is server-configured; tool arguments can only provide query, topK, and an optional narrowing scope.",
     parameters: searchAllSchema,
     async execute(_toolCallId, params) {
       const query = params.query.trim();
@@ -13552,92 +13201,8 @@ var init_search_all_tool = __esm(() => {
   });
 });
 
-// src/agent/search-bm25-tool.ts
-import { Type as Type8 } from "typebox";
-function createSearchBM25DocumentsTool(getMethod, resolveScope = (scope) => scope) {
-  return {
-    name: SEARCH_BM25_DOCUMENTS_TOOL_NAME,
-    label: "Search BM25 Documents",
-    description: "Search parsed document mirrors with MinSync lexical BM25 ranking. Use for exact terms, repeated terms, headings, identifiers, and folder-scoped document search.",
-    parameters: searchBM25Schema,
-    async execute(_toolCallId, params) {
-      const method = getMethod();
-      if (!method) {
-        return unavailableResult("BM25 is not configured for this AutoRAG agent", {
-          readiness: "disabled",
-          engine: "none"
-        });
-      }
-      const status = method.getStatus();
-      if (params.query.trim().length === 0) {
-        return {
-          content: [{ type: "text", text: "BM25 query was empty; no documents searched." }],
-          details: {
-            method: "bm25",
-            resultCount: 0,
-            sources: [],
-            readiness: status.readiness,
-            engine: status.engine
-          }
-        };
-      }
-      const scope = resolveScope(params.scope);
-      try {
-        const results = await method.retrieve(params.query, {
-          topK: params.topK,
-          scope
-        });
-        return {
-          content: [{ type: "text", text: formatResults2(results, method.getStatus()) }],
-          details: {
-            method: "bm25",
-            resultCount: results.length,
-            sources: [...new Set(results.map((result) => result.source))],
-            readiness: method.getStatus().readiness,
-            engine: method.getStatus().engine
-          }
-        };
-      } catch (error) {
-        const nextStatus = method.getStatus();
-        const message = error instanceof BM25UnavailableError ? error.message : `BM25 search failed: ${String(error)}`;
-        return unavailableResult(message, nextStatus);
-      }
-    }
-  };
-}
-function unavailableResult(message, status) {
-  return {
-    content: [{ type: "text", text: `${message}
-readiness=${status.readiness}; engine=${status.engine}` }],
-    details: { method: "bm25", resultCount: 0, sources: [], readiness: status.readiness, engine: status.engine }
-  };
-}
-function formatResults2(results, status) {
-  if (results.length === 0)
-    return `No BM25 results. readiness=${status.readiness}; engine=${status.engine}`;
-  const rows = results.map((result, index) => {
-    const line = result.content.replace(/\s+/gu, " ").slice(0, 500);
-    return `[${index + 1}] ${result.source} score=${result.score.toFixed(4)}
-${line}`;
-  });
-  return `BM25 results (readiness=${status.readiness}; engine=${status.engine}):
-
-${rows.join(`
-
-`)}`;
-}
-var SEARCH_BM25_DOCUMENTS_TOOL_NAME = "lexical_search_local_docs", searchBM25Schema;
-var init_search_bm25_tool = __esm(() => {
-  init_bm25();
-  searchBM25Schema = Type8.Object({
-    query: Type8.String({ description: "Lexical query to search in parsed document mirrors with BM25." }),
-    topK: Type8.Optional(Type8.Integer({ description: "Maximum number of BM25 chunks to return." })),
-    scope: Type8.Optional(Type8.String({ description: "Optional opaque virtual-path scope, e.g. /docs or /docs/**." }))
-  });
-});
-
 // src/agent/search-datasource-tool.ts
-import { Type as Type9 } from "typebox";
+import { Type as Type8 } from "typebox";
 function createSearchDatasourceDocumentsTool(provider) {
   return {
     name: SEARCH_DATASOURCE_DOCUMENTS_TOOL_NAME,
@@ -13657,7 +13222,7 @@ function createSearchDatasourceDocumentsTool(provider) {
         scope: params.scope
       });
       return {
-        content: [{ type: "text", text: formatResults3(results, diagnostics) }],
+        content: [{ type: "text", text: formatResults2(results, diagnostics) }],
         details: {
           method: "datasource",
           resultCount: results.length,
@@ -13668,7 +13233,7 @@ function createSearchDatasourceDocumentsTool(provider) {
     }
   };
 }
-function formatResults3(results, diagnostics) {
+function formatResults2(results, diagnostics) {
   const diagnosticSummary = diagnostics.length > 0 ? `
 
 Diagnostics: ${diagnostics.map((d) => `${d.source ?? "datasource"}:${d.code}`).join(", ")}` : "";
@@ -13687,10 +13252,10 @@ ${rows.join(`
 }
 var SEARCH_DATASOURCE_DOCUMENTS_TOOL_NAME = "search_datasource_documents", searchDatasourceSchema;
 var init_search_datasource_tool = __esm(() => {
-  searchDatasourceSchema = Type9.Object({
-    query: Type9.String({ description: "Query to search across configured external datasource skills." }),
-    topK: Type9.Optional(Type9.Integer({ description: "Maximum number of datasource chunks to return." })),
-    scope: Type9.Optional(Type9.String({ description: "Optional opaque datasource scope, e.g. /kakao/account or /kakao/account/**." }))
+  searchDatasourceSchema = Type8.Object({
+    query: Type8.String({ description: "Query to search across configured external datasource skills." }),
+    topK: Type8.Optional(Type8.Integer({ description: "Maximum number of datasource chunks to return." })),
+    scope: Type8.Optional(Type8.String({ description: "Optional opaque datasource scope, e.g. /kakao/account or /kakao/account/**." }))
   });
 });
 
@@ -13744,7 +13309,7 @@ function normalizeEntryEvidenceRefs(entry) {
 function recordStructuredResultsSession(sessionId, query, details, sessions, memory, componentDiagnostics = []) {
   const resultNumbers = details.results.map((result) => result.number).sort((a, b) => a - b);
   const mappingNumbers = details.mapping.map((entry) => entry.number).sort((a, b) => a - b);
-  const oneToOne = resultNumbers.length === mappingNumbers.length && resultNumbers.every((number2, index) => number2 === mappingNumbers[index]);
+  const oneToOne = resultNumbers.length === mappingNumbers.length && resultNumbers.every((number, index) => number === mappingNumbers[index]);
   if (!oneToOne) {
     throw new Error("emit_autorag_results: result numbers and mapping numbers must be one-to-one");
   }
@@ -13830,7 +13395,7 @@ var init_search_documents = __esm(() => {
 });
 
 // src/agent/search-minsync-tool.ts
-import { Type as Type10 } from "typebox";
+import { Type as Type9 } from "typebox";
 function createSearchMinSyncDocumentsTool(getMethod, resolveScope = (scope) => scope) {
   return {
     name: SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME,
@@ -13840,10 +13405,10 @@ function createSearchMinSyncDocumentsTool(getMethod, resolveScope = (scope) => s
     async execute(_toolCallId, params) {
       const method = getMethod();
       if (!method) {
-        return unavailableResult2("MinSync semantic search is not configured for this AutoRAG agent");
+        return unavailableResult("MinSync semantic search is not configured for this AutoRAG agent");
       }
       if (method.isBinaryMissing()) {
-        return unavailableResult2("MinSync semantic search is unavailable; the configured binary is missing.");
+        return unavailableResult("MinSync semantic search is unavailable; the configured binary is missing.");
       }
       if (params.query.trim().length === 0) {
         return {
@@ -13858,7 +13423,7 @@ function createSearchMinSyncDocumentsTool(getMethod, resolveScope = (scope) => s
           scope
         });
         return {
-          content: [{ type: "text", text: formatResults4(results) }],
+          content: [{ type: "text", text: formatResults3(results) }],
           details: {
             method: "semantic_search_local_docs",
             resultCount: results.length,
@@ -13867,12 +13432,12 @@ function createSearchMinSyncDocumentsTool(getMethod, resolveScope = (scope) => s
           }
         };
       } catch {
-        return unavailableResult2("MinSync semantic search is unavailable; the query could not be completed.");
+        return unavailableResult("MinSync semantic search is unavailable; the query could not be completed.");
       }
     }
   };
 }
-function unavailableResult2(message) {
+function unavailableResult(message) {
   return {
     content: [{ type: "text", text: message }],
     details: {
@@ -13883,7 +13448,7 @@ function unavailableResult2(message) {
     }
   };
 }
-function formatResults4(results) {
+function formatResults3(results) {
   if (results.length === 0)
     return "No MinSync results.";
   const rows = results.map((result, index) => {
@@ -13899,12 +13464,12 @@ ${rows.join(`
 }
 var SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME = "semantic_search_local_docs", searchMinSyncSchema;
 var init_search_minsync_tool = __esm(() => {
-  searchMinSyncSchema = Type10.Object({
-    query: Type10.String({
+  searchMinSyncSchema = Type9.Object({
+    query: Type9.String({
       description: "Semantic query to search parsed document mirrors with MinSync vector retrieval."
     }),
-    topK: Type10.Optional(Type10.Integer({ description: "Maximum number of MinSync semantic chunks to return." })),
-    scope: Type10.Optional(Type10.String({ description: "Optional opaque virtual-path scope, e.g. /docs or /docs/**." }))
+    topK: Type9.Optional(Type9.Integer({ description: "Maximum number of MinSync semantic chunks to return." })),
+    scope: Type9.Optional(Type9.String({ description: "Optional opaque virtual-path scope, e.g. /docs or /docs/**." }))
   });
 });
 
@@ -13921,7 +13486,6 @@ function buildSystemPrompt(config) {
     toolLine(config, "bash", "read and inspect configured document collections with ls, find, grep, cat, and similar tools"),
     toolLine(config, "jikji_find", "local discovery through Jikji answer packs"),
     toolLine(config, "search_all_documents", "fan out across every configured retrieval method and merge results"),
-    toolLine(config, "lexical_search_local_docs", "MinSync-backed lexical BM25 search over parsed document mirrors"),
     toolLine(config, "semantic_search_local_docs", "semantic MinSync search over parsed document mirrors"),
     toolLine(config, "search_datasource_documents", "search authorized external datasources; scope may only narrow access"),
     toolLine(config, "load_datasource_skill", "load instructions for an authorized datasource"),
@@ -13932,7 +13496,6 @@ function buildSystemPrompt(config) {
       "bash",
       "jikji_find",
       "search_all_documents",
-      "lexical_search_local_docs",
       "semantic_search_local_docs",
       "search_datasource_documents",
       "load_datasource_skill",
@@ -13965,8 +13528,8 @@ Your job is to retrieve candidates, read the relevant source material directly,
 
 ## Workflow
 
-1. **PLAN** — Understand the query and review the preloaded initial retrieval context.
-2. **RETRIEVE** — Use MinSync BM25, MinSync vector, MinSync hybrid, combined retrieval, Jikji, datasource search, or direct filesystem discovery as appropriate.
+1. **PLAN** — Decide whether the query is answerable from stable general knowledge, memory, or intrinsic model knowledge. If so, answer immediately without retrieval.
+2. **RETRIEVE** — Use MinSync lexical/vector/hybrid retrieval, combined retrieval, Jikji, datasource search, or direct filesystem discovery as appropriate.
 3. **READ** — Use \`bash\` to open and verify relevant local files. Do not curate from search snippets alone when source files are available.
 4. **JUDGE** — Evaluate relevance, sufficiency, conflicts, uncertainty, and temporal context.
 5. **CURATE** — Produce concise numbered knowledge units grounded in source evidence.
@@ -13979,14 +13542,17 @@ ${toolLines.join(`
 ${noSearchTools}
 ## Search Strategy
 
-- Before additional searching, inspect the initial retrieval context supplied with the query. It contains bounded Jikji, semantic MinSync, and lexical BM25 candidates collected in parallel; treat it as a starting slate, not as verified final evidence.
+- For generic, stable questions answer directly from knowledge or memory without searching. For source-dependent questions, baseline MinSync and Jikji retrieval starts before the model's search decision and supplies up to 50 candidates per method; inspect it first and treat it as unverified evidence.
 - Start with the most specific exact term, identifier, filename glob, or regex that preserves the query intent.
 - Use \`search_all_documents\` when multiple configured retrieval methods can help.
-- Use MinSync-backed BM25 for exact terminology, MinSync vector search for semantic similarity, and \`search_all_documents\` when hybrid ranking over the same MinSync chunks can help.
+- Use MinSync lexical mode for exact terminology, MinSync vector search for semantic similarity, and \`search_all_documents\` when hybrid ranking over the same MinSync chunks can help.
 - Use \`bash\` to read already-retrieved local files with cat/head/sed. find/grep/rg must be small and bounded: one already-known directory from retrieval, a tight pattern, and a cap (head, maxdepth, or file types). Never recursively scan a whole search root (Downloads, Documents, Desktop, or /); those calls miss the bash timeout and stall the search loop.
 - If retrieval is empty, retry a simpler query or synonyms through retrieval tools first. Do not widen filesystem discovery to compensate.
 - Slash-prefixed datasource IDs such as /kakao/..., /gmail/..., /slack/..., /discord/..., and /github/... are virtual, not OS paths. Do not bash them. Search them with \`search_datasource_documents\`.
 - Cross-check important claims against the original source and preserve real source paths.
+- When more searching is needed, first emit a brief, query-specific 1–2 line progress update describing the best current hypothesis and what is being checked next; baseline retrieval is already running in parallel. Never repeat a generic status message.
+- Do not use broad grep/find or recursive filesystem scans. Only inspect a narrow neighborhood around a retrieved candidate when the evidence clearly points there.
+- Do not query the same datasource more than three times. After three attempts, stop searching it and conclude from the evidence available.
 
 ${duplicateManagement}
 ## External Datasource Skills
@@ -14090,7 +13656,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 } from "node:fs";
-import { dirname as dirname15, join as join22, resolve as resolve11 } from "node:path";
+import { dirname as dirname14, join as join21, resolve as resolve11 } from "node:path";
 import { Agent } from "@earendil-works/pi-agent-core";
 import { streamSimple } from "@earendil-works/pi-ai/compat";
 
@@ -14111,6 +13677,10 @@ class AutoRAGAgent {
   resultCapture;
   autoRefreshTimer;
   refreshing = false;
+  jikjiPrepareInFlight;
+  jikjiReady = false;
+  minSyncPrepareInFlight;
+  minSyncReady = false;
   refreshState = {
     inFlight: false,
     lastOutcome: "never",
@@ -14130,7 +13700,6 @@ class AutoRAGAgent {
   merger = new ResultMerger;
   datasourceFilter = new DatasourceResultFilter;
   minSyncMethod;
-  bm25Method;
   jikjiClient;
   datasourceSkills;
   datasourceAccessOptions;
@@ -14144,6 +13713,7 @@ class AutoRAGAgent {
   searchTimeoutMs;
   maxSearchToolCalls;
   searchToolCallCount = 0;
+  sourceSearchCallCounts = new Map;
   constructor(options) {
     const { manifestDir, memoryPath } = options;
     this.configuredModel = options.model;
@@ -14176,16 +13746,9 @@ class AutoRAGAgent {
         ...minSyncOpts,
         root: this.workspaceProjectRoot
       });
+      this.minSyncReady = this.minSyncMethod.isReady();
       this.methodRegistry.register(this.minSyncMethod);
       this.methodRegistry.register(new MinSyncHybridMethod({ ...minSyncOpts, root: this.workspaceProjectRoot }));
-      if (options.bm25 !== false) {
-        const bm25Opts = { ...minSyncOpts, autoInstall: true, ...options.bm25 ?? {} };
-        this.bm25Method = new MinSyncBM25Method({
-          ...bm25Opts,
-          root: this.workspaceProjectRoot
-        });
-        this.methodRegistry.register(this.bm25Method);
-      }
     }
     for (const skill of this.datasourceSkills) {
       for (const method of skill.retrievalMethods())
@@ -14196,13 +13759,13 @@ class AutoRAGAgent {
         ...options.jikji ?? {},
         root: this.workspaceProjectRoot
       });
+      this.jikjiReady = this.searchPaths.every((searchPath) => this.jikjiClient?.isPrepared(searchPath) === true);
     }
-    const memPath = memoryPath ?? join22(resolveAutoRAGHome(), "memory.json");
+    const memPath = memoryPath ?? join21(resolveAutoRAGHome(), "memory.json");
     this.memory = new RetrievalMemory({ storagePath: memPath });
     this.memory.load();
-    this.runLogger = new AutoRAGRunLogger(join22(dirname15(memPath), "logs", "runs.jsonl"));
+    this.runLogger = new AutoRAGRunLogger(join21(dirname14(memPath), "logs", "runs.jsonl"));
     const checkMemoryTool = createCheckMemoryTool(this.memory);
-    const searchBM25Tool = createSearchBM25DocumentsTool(() => this.bm25Method, (scope) => this.resolveRetrievalScope(scope));
     const searchDatasourceTool = createSearchDatasourceDocumentsTool(this);
     const searchMinSyncTool = createSearchMinSyncDocumentsTool(() => this.minSyncMethod, (scope) => this.resolveRetrievalScope(scope));
     const searchAllTool = createSearchAllDocumentsTool(this);
@@ -14216,7 +13779,6 @@ class AutoRAGAgent {
     const reservedNames = new Set([
       BASH_TOOL_NAME,
       "check_memory",
-      SEARCH_BM25_DOCUMENTS_TOOL_NAME,
       SEARCH_DATASOURCE_DOCUMENTS_TOOL_NAME,
       LOAD_DATASOURCE_SKILL_TOOL_NAME,
       EMIT_AUTORAG_RESULTS_TOOL_NAME,
@@ -14238,7 +13800,6 @@ class AutoRAGAgent {
       bashTool,
       ...callerTools,
       checkMemoryTool,
-      searchBM25Tool,
       searchMinSyncTool,
       searchAllTool,
       searchDatasourceTool,
@@ -14253,7 +13814,7 @@ class AutoRAGAgent {
         return false;
       seenToolNames.add(tool.name);
       return true;
-    });
+    }).map((tool) => SEARCH_TOOLS.includes(tool.name) ? this.withPerSourceSearchLimit(tool) : tool);
     this.tools = tools;
     const toolNames = tools.map((tool) => tool.name);
     this.baseSystemPromptConfig = {
@@ -14362,6 +13923,27 @@ ${summary}
     }));
     return unsubscribers;
   }
+  withPerSourceSearchLimit(tool) {
+    return {
+      ...tool,
+      execute: async (...args) => {
+        const count = this.sourceSearchCallCounts.get(tool.name) ?? 0;
+        if (count >= 3) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `${tool.name} has reached its three-query limit. Do not call it again; conclude from the evidence already gathered.`
+              }
+            ],
+            details: { method: tool.name, resultCount: 0, sources: [], limitReached: true }
+          };
+        }
+        this.sourceSearchCallCounts.set(tool.name, count + 1);
+        return tool.execute(...args);
+      }
+    };
+  }
   recordSearchToolEvent(event) {
     if (event.type !== "tool_execution_end" || !this.lastQuery)
       return;
@@ -14460,8 +14042,11 @@ ${summary}
     options = this.normalizeRetrievalOptions(options);
     this.activeRun = true;
     this.searchToolCallCount = 0;
+    this.sourceSearchCallCounts.clear();
     this.lastQuery = trimmedQuery;
     this.lastSessionId = sessionId;
+    this.scheduleJikjiPrepare();
+    this.scheduleMinSyncPrepare();
     let captured;
     let session;
     let unsubscribers = [];
@@ -14486,8 +14071,14 @@ ${summary}
       try {
         await Promise.race([
           (async () => {
-            const initialRetrievalContext = await this.prefetchInitialRetrievalContext(trimmedQuery, options);
-            await session.prompt(this.buildSearchPrompt(trimmedQuery, options, initialRetrievalContext));
+            const retrievalPromise = this.prefetchInitialRetrievalContext(trimmedQuery, options);
+            await session.prompt(this.buildSearchPrompt(trimmedQuery, options));
+            if (captured === undefined) {
+              const initialRetrievalContext = await retrievalPromise;
+              await session.prompt(`Baseline retrieval is complete. Use this evidence before deciding whether additional search is needed:
+
+${initialRetrievalContext}`);
+            }
           })(),
           new Promise((_, reject) => {
             timeout = setTimeout(() => {
@@ -14546,6 +14137,73 @@ ${summary}
       this.activeRun = false;
     }
   }
+  async* searchDocumentsStream(query, options = {}) {
+    const queue = [];
+    let progressBuffer = "";
+    let wake;
+    let settled = false;
+    const unsubscribe = this.subscribe((event) => {
+      if (event.type !== "message_update" || event.assistantMessageEvent.type !== "text_delta")
+        return;
+      const text = event.assistantMessageEvent.delta;
+      if (text.trim().length === 0)
+        return;
+      progressBuffer += text;
+      if (!/[.!?。！？]\s*$/u.test(progressBuffer))
+        return;
+      queue.push({
+        type: "progress",
+        sessionId: this.lastSessionId ?? "",
+        query: query.trim(),
+        text: progressBuffer
+      });
+      progressBuffer = "";
+      wake?.();
+      wake = undefined;
+    });
+    queue.push({
+      type: "progress",
+      sessionId: "",
+      query: query.trim(),
+      text: "Reviewing the query."
+    });
+    const run = this.searchDocuments(query, options).then((response) => {
+      if (progressBuffer.trim() !== "") {
+        queue.push({
+          type: "progress",
+          sessionId: this.lastSessionId ?? "",
+          query: query.trim(),
+          text: progressBuffer
+        });
+        progressBuffer = "";
+      }
+      queue.push({ type: "complete", response });
+    }).catch((error) => {
+      settled = true;
+      wake?.();
+      throw error;
+    }).finally(() => {
+      settled = true;
+      wake?.();
+    });
+    try {
+      while (!settled || queue.length > 0) {
+        if (queue.length === 0) {
+          await new Promise((resolve) => {
+            wake = resolve;
+          });
+          continue;
+        }
+        yield queue.shift();
+      }
+      await run;
+    } finally {
+      unsubscribe();
+      await run.catch(() => {
+        return;
+      });
+    }
+  }
   datasourceAccessContext(options = {}) {
     return new DatasourceAccessContext({
       allowedTags: options.allowedTags ?? this.datasourceAccessOptions.allowedTags,
@@ -14604,17 +14262,6 @@ ${summary}
         source: "tools"
       });
     }
-    const bm25 = this.bm25Method?.getStatus();
-    if (bm25 !== undefined) {
-      if (bm25.readiness === "dependency_unavailable" || bm25.readiness === "index_missing" || bm25.readiness === "error") {
-        diagnostics.push({
-          code: "bm25-unavailable",
-          severity: "warning",
-          message: "BM25 lexical search is unavailable; results rely on other retrieval paths.",
-          source: "bm25"
-        });
-      }
-    }
     if (this.minSyncMethod?.isBinaryMissing()) {
       diagnostics.push({
         code: "minsync-unavailable",
@@ -14629,51 +14276,84 @@ ${summary}
     return diagnostics;
   }
   async prefetchInitialRetrievalContext(query, options) {
-    const retrieveOptions = { topK: 5, scope: options.scope };
-    const [jikji, vector, bm25] = await Promise.all([
-      this.jikjiClient === undefined ? Promise.resolve(undefined) : this.findJikji(query, { topK: 5 }).catch(() => {
+    const retrieveOptions = { topK: 50, scope: options.scope };
+    const vectorReady = this.minSyncMethod?.isReady() === true;
+    const [jikji, vector] = await Promise.all([
+      this.jikjiClient === undefined ? Promise.resolve(undefined) : this.findJikji(query, { topK: 50 }).catch(() => {
         return;
       }),
-      this.minSyncMethod?.retrieve(query, retrieveOptions).catch(() => []),
-      this.bm25Method?.retrieve(query, retrieveOptions).catch(() => [])
+      vectorReady ? this.minSyncMethod?.retrieve(query, retrieveOptions).catch(() => []) : Promise.resolve([])
     ]);
     const sections = [];
     if (jikji?.answerPack !== undefined) {
       sections.push(`Jikji initial candidates (preserve order when agent_should_not_rerank=true):
-${jikji.answerPack.answerPaths.slice(0, 5).map((path, index) => `[${index + 1}] ${path}`).join(`
+${jikji.answerPack.answerPaths.slice(0, 50).map((path, index) => `[${index + 1}] ${path}`).join(`
 `)}`);
     }
-    const formatResults5 = (label, results) => {
+    const formatResults = (label, results) => {
       if (!results || results.length === 0)
         return;
+      const seen = new Set;
       sections.push(`${label} initial candidates:
-${results.slice(0, 5).map((result, index) => `[${index + 1}] ${result.source}
+${results.filter((result) => {
+        const key = `${result.source}\x00${result.content}`;
+        if (seen.has(key))
+          return false;
+        seen.add(key);
+        return true;
+      }).slice(0, 50).map((result, index) => `[${index + 1}] ${result.source}
 ${result.content.replace(/\s+/gu, " ").slice(0, 400)}`).join(`
 `)}`);
     };
-    formatResults5("MinSync semantic", vector);
-    formatResults5("MinSync lexical BM25", bm25);
+    formatResults("MinSync semantic", vector);
     return sections.length === 0 ? "No initial retrieval candidates were available; use the configured tools and report degradation honestly." : sections.join(`
 
 `);
   }
+  scheduleMinSyncPrepareForTest() {
+    return this.scheduleMinSyncPrepare();
+  }
+  scheduleMinSyncPrepare() {
+    if (this.minSyncMethod === undefined || this.minSyncReady || this.minSyncPrepareInFlight !== undefined) {
+      return this.minSyncPrepareInFlight;
+    }
+    this.minSyncPrepareInFlight = Promise.resolve().then(async () => {
+      await this.syncParsedMirrors(false);
+      if (!this.minSyncMethod)
+        return;
+      this.minSyncReady = this.minSyncMethod.isReady();
+      if (this.minSyncReady)
+        return;
+      const result = await this.minSyncMethod.sync();
+      this.minSyncReady = result?.ok === true;
+      this.refreshState = { ...this.refreshState, minsync: result };
+      return result;
+    }).catch(() => {
+      return;
+    }).finally(() => {
+      this.minSyncPrepareInFlight = undefined;
+    });
+    return this.minSyncPrepareInFlight;
+  }
   buildSearchPrompt(query, options, initialRetrievalContext) {
     const limit = typeof options.topK === "number" ? ` Return at most ${options.topK} curated results.` : "";
     const scope = options.scope ? ` Restrict search to virtual path scope ${options.scope}.` : "";
     return `Find and curate information for this original query: ${query}${limit}${scope}
 
-` + `Initial retrieval context (Jikji, MinSync semantic, and MinSync lexical searches were run in parallel before this turn):
-` + `${initialRetrievalContext ?? "Not preloaded; use the available retrieval tools."}
+` + `Start by deciding whether this is answerable from general knowledge or memory. If it is a generic, stable question, answer it immediately without retrieval and emit the structured result. ` + `Otherwise, baseline MinSync and Jikji retrieval is already running in parallel; do not emit final results until its next message arrives.
+
+` + `Baseline retrieval context:
+${initialRetrievalContext ?? "Pending; continue only with a brief progress statement."}
 
-` + `Treat this as candidate evidence, verify important claims against source files, and use additional tools when needed. ` + `Use the available retrieval tools to find candidates, then use bash to read and verify the relevant source files directly. ` + `Judge relevance, conflicts, freshness, and sufficiency in this agent loop. Preserve real source paths and evidence excerpts in the result mapping.
+` + `Treat candidates as unverified evidence, verify important claims against source files, and use additional tools when needed. ` + `Use the available retrieval tools to find candidates, then use bash to read and verify the relevant source files directly. ` + `Judge relevance, conflicts, freshness, and sufficiency in this agent loop. Preserve real source paths and evidence excerpts in the result mapping.
 
-` + `When finished, call ${EMIT_AUTORAG_RESULTS_TOOL_NAME} exactly once as your final action with the curated ` + `results and the internal number-to-source mapping.`;
+` + `If more search is needed, first write a brief 1–2 line progress update stating the best current hypothesis and what you are checking next, then call retrieval tools. ` + `Never repeat a generic status message. Do not use broad grep/find or recursive filesystem scans: only inspect a path or narrow neighborhood surfaced by retrieval, and only when evidence clearly points there. ` + `Do not query the same datasource more than three times. After three attempts, stop searching that datasource and conclude from the evidence available. ` + `When finished, call ${EMIT_AUTORAG_RESULTS_TOOL_NAME} exactly once as your final action with the curated ` + `results and the internal number-to-source mapping.`;
   }
   async refresh(force = false, opts) {
     const methods = opts?.methods;
     const allMethods = methods === undefined;
     const wants = (m) => allMethods || methods.includes(m);
-    const needsParsed = allMethods || wants("parsed") || wants("bm25") || wants("minsync");
+    const needsParsed = allMethods || wants("parsed") || wants("minsync");
     this.refreshState = {
       ...this.refreshState,
       inFlight: true,
@@ -14681,13 +14361,9 @@ ${result.content.replace(/\s+/gu, " ").slice(0, 400)}`).join(`
     };
     try {
       const summary = needsParsed ? await this.syncParsedMirrors(force) : await this.scanMirrorStaleness();
-      if (wants("bm25") || wants("minsync") || allMethods) {
-        removeLegacyBm25Artifacts(this.workspaceProjectRoot);
-      }
       const minsync = wants("minsync") ? await this.syncMinSync() : undefined;
-      const bm25 = wants("bm25") ? await this.syncBM25(minsync) : undefined;
       const datasources = wants("datasources") ? await this.indexDatasources() : [];
-      const jikji = wants("jikji") ? await this.executeJikjiPrepare() : undefined;
+      const jikji = allMethods || wants("jikji") || wants("minsync") ? await this.executeJikjiPrepare() : undefined;
       this.retrievalScopeBindings = buildRetrievalScopeBindings(this.workspaceProjectRoot, this.searchPaths, this.configuredSearchPaths);
       const jikjiDiagnostics = (jikji ?? []).map((result) => jikjiPrepareDiagnostic(result)).filter((diag) => diag !== undefined);
       this.refreshState = {
@@ -14711,9 +14387,8 @@ ${result.content.replace(/\s+/gu, " ").slice(0, 400)}`).join(`
         ...minsync.reason !== undefined ? { reason: minsync.reason } : {}
       } : undefined;
       return {
-        ...bm25 ? { ...summary } : summary,
+        ...summary,
         diagnostics: [...this.startupDiagnostics, ...summary.diagnostics],
-        ...bm25 ? { bm25 } : {},
         minsync: publicMinsync,
         datasources
       };
@@ -14783,11 +14458,8 @@ ${result.content.replace(/\s+/gu, " ").slice(0, 400)}`).join(`
   }
   refreshComponentStatus() {
     const status = {};
-    const bm25 = this.bm25Method?.getStatus();
-    if (bm25 !== undefined)
-      status.bm25 = bm25.readiness;
     if (this.minSyncMethod !== undefined) {
-      status.minsync = this.minSyncMethod.isBinaryMissing() ? "unavailable" : this.refreshState.minsync?.ok === false ? "degraded" : this.refreshState.minsync?.ok ? "ready" : "configured";
+      status.minsync = this.minSyncMethod.isBinaryMissing() ? "unavailable" : this.refreshState.minsync?.ok === false ? "degraded" : this.minSyncMethod.isReady() ? "ready" : "configured";
     }
     if (this.jikjiClient !== undefined) {
       status.jikji = this.refreshState.jikjiDiagnostics.length > 0 ? "degraded" : "configured";
@@ -14853,7 +14525,7 @@ ${result.content.replace(/\s+/gu, " ").slice(0, 400)}`).join(`
       written: 0,
       deleted: 0,
       skipped: 0,
-      indexPath: join22(this.workspaceProjectRoot, PARSED_MIRROR_SUBDIR),
+      indexPath: join21(this.workspaceProjectRoot, PARSED_MIRROR_SUBDIR),
       diagnostics
     };
   }
@@ -14874,13 +14546,11 @@ ${result.content.replace(/\s+/gu, " ").slice(0, 400)}`).join(`
     }
     return { excluded };
   }
-  async syncBM25(minsync) {
-    if (this.bm25Method === undefined)
-      return;
-    return this.bm25Method.syncFromMinSync(minsync ?? await this.bm25Method.sync());
-  }
   async syncMinSync() {
-    return this.minSyncMethod?.sync();
+    const result = await this.minSyncMethod?.sync();
+    this.minSyncReady = result?.ok === true;
+    this.refreshState = { ...this.refreshState, minsync: result };
+    return result;
   }
   async prepareJikji() {
     const results = await this.executeJikjiPrepare();
@@ -14893,8 +14563,20 @@ ${result.content.replace(/\s+/gu, " ").slice(0, 400)}`).join(`
     for (const sourcePath of this.searchPaths) {
       results.push(await this.jikjiClient.prepare(sourcePath));
     }
+    this.jikjiReady = results.length === this.searchPaths.length && results.every((result) => result.ok);
     return results;
   }
+  scheduleJikjiPrepare() {
+    if (this.jikjiClient === undefined || this.jikjiPrepareInFlight !== undefined)
+      return;
+    this.jikjiPrepareInFlight = Promise.resolve().then(async () => {
+      const results = await this.executeJikjiPrepare();
+      const diagnostics = (results ?? []).map((result) => jikjiPrepareDiagnostic(result)).filter((diag) => diag !== undefined);
+      this.refreshState = { ...this.refreshState, jikjiDiagnostics: diagnostics };
+    }).catch(() => {}).finally(() => {
+      this.jikjiPrepareInFlight = undefined;
+    });
+  }
   sanitizeJikjiPrepareResult(result) {
     if (result.ok) {
       return {
@@ -14914,6 +14596,23 @@ ${result.content.replace(/\s+/gu, " ").slice(0, 400)}`).join(`
     if (this.jikjiClient === undefined) {
       return { answerPack: undefined, policy: undefined, diagnostics: [], roots: [], perRoot: [] };
     }
+    if (!this.jikjiReady) {
+      this.scheduleJikjiPrepare();
+      return {
+        answerPack: undefined,
+        policy: undefined,
+        diagnostics: [
+          {
+            code: "jikji-unavailable",
+            severity: "warning",
+            message: "Jikji is not prepared yet; background preparation started and this turn is falling back.",
+            source: "jikji"
+          }
+        ],
+        roots: this.searchPaths,
+        perRoot: []
+      };
+    }
     const sourceRoots = planJikjiSourceRoots(this.searchPaths);
     const findOpts = {
       topK: opts?.topK,
@@ -15188,7 +14887,6 @@ var init_agent = __esm(() => {
   init_paths();
   init_sync();
   init_run_log();
-  init_bm25();
   init_scope();
   init_bash_tool();
   init_datasource_skill();
@@ -15197,7 +14895,6 @@ var init_agent = __esm(() => {
   init_jikji_find_tool();
   init_local_model();
   init_search_all_tool();
-  init_search_bm25_tool();
   init_search_datasource_tool();
   init_search_documents();
   init_search_minsync_tool();
@@ -15207,18 +14904,12 @@ var init_agent = __esm(() => {
     BASH_TOOL_NAME,
     SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME,
     SEARCH_ALL_DOCUMENTS_TOOL_NAME,
-    SEARCH_BM25_DOCUMENTS_TOOL_NAME,
     SEARCH_DATASOURCE_DOCUMENTS_TOOL_NAME,
     JIKJI_FIND_TOOL_NAME
   ];
 });
 
 // src/cli/commands/refresh.ts
-var exports_refresh = {};
-__export(exports_refresh, {
-  parseMethodFlag: () => parseMethodFlag,
-  runRefresh: () => runRefresh
-});
 async function runRefresh(ctx) {
   try {
     const config = resolveConfig({ flags: ctx.flags, cwd: ctx.cwd });
@@ -15246,9 +14937,9 @@ function parseMethodFlag(flag) {
     }
   }
   if (entries.includes("all")) {
-    return ["parsed", "bm25", "minsync", "datasources", "jikji"];
+    return ["parsed", "minsync", "datasources", "jikji"];
   }
-  const order = ["parsed", "bm25", "minsync", "datasources", "jikji"];
+  const order = ["parsed", "minsync", "datasources", "jikji"];
   const seen = new Set;
   for (const m of order) {
     if (entries.includes(m))
@@ -15260,14 +14951,10 @@ var ALL_METHOD_NAMES;
 var init_refresh = __esm(() => {
   init_agent();
   init_config2();
-  ALL_METHOD_NAMES = ["all", "bm25", "minsync", "parsed", "datasources", "jikji"];
+  ALL_METHOD_NAMES = ["all", "minsync", "parsed", "datasources", "jikji"];
 });
 
 // src/cli/commands/status.ts
-var exports_status = {};
-__export(exports_status, {
-  runStatus: () => runStatus
-});
 async function runStatus(ctx) {
   try {
     const config = resolveConfig({ flags: ctx.flags, cwd: ctx.cwd });
@@ -15286,11 +14973,6 @@ var init_status = __esm(() => {
 });
 
 // src/cli/commands/search.ts
-var exports_search = {};
-__export(exports_search, {
-  classifySearchHealthHint: () => classifySearchHealthHint,
-  runSearch: () => runSearch
-});
 function classifySearchHealthHint(error) {
   const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
   const name = error instanceof Error ? error.name : "";
@@ -15385,8 +15067,18 @@ async function runSearch(ctx, deps = {}) {
   }
   const options = buildSearchOptions(ctx.flags);
   try {
-    const resp = await agent.searchDocuments(query, options);
-    ctx.stdout(renderSearch(resp, { json: ctx.json, debug: ctx.debug }));
+    for await (const event of agent.searchDocumentsStream(query, options)) {
+      switch (event.type) {
+        case "progress":
+          if (event.text.trim() === "")
+            break;
+          ctx.stdout(ctx.json ? JSON.stringify({ type: "progress", text: event.text }) : event.text);
+          break;
+        case "complete":
+          ctx.stdout(renderSearch(event.response, { json: ctx.json, debug: ctx.debug }));
+          break;
+      }
+    }
     return 0;
   } catch (error) {
     const hint = classifySearchHealthHint(error);
@@ -15419,10 +15111,6 @@ var init_search = __esm(() => {
 });
 
 // src/cli/commands/feedback.ts
-var exports_feedback = {};
-__export(exports_feedback, {
-  runFeedback: () => runFeedback
-});
 function parseCsvInts(value) {
   if (typeof value !== "string" || value.trim() === "")
     return [];
@@ -15443,8 +15131,8 @@ async function runFeedback(ctx) {
     return 2;
   }
   const feedback = [
-    ...usefulNumbers.map((number2) => ({ number: number2, useful: true })),
-    ...notUsefulNumbers.map((number2) => ({ number: number2, useful: false }))
+    ...usefulNumbers.map((number) => ({ number, useful: true })),
+    ...notUsefulNumbers.map((number) => ({ number, useful: false }))
   ];
   let memoryPath;
   try {
@@ -15478,11 +15166,86 @@ var init_feedback = __esm(() => {
   init_config2();
 });
 
-// src/cli/commands/memory.ts
-var exports_memory = {};
-__export(exports_memory, {
-  runMemory: () => runMemory
+// src/cli/commands/evidence.ts
+function parseResultNumber(value) {
+  if (typeof value !== "string" || value.trim() === "")
+    return;
+  const number = Number(value);
+  return Number.isInteger(number) && number > 0 ? number : undefined;
+}
+function evidenceFor(schema, sessionId, resultNumber) {
+  const results = schema.curatedResults.filter((result) => result.sessionId === sessionId).filter((result) => resultNumber === undefined || result.number === resultNumber).sort((a, b) => a.number - b.number).map((result) => {
+    const chunks = result.evidenceIds.map((id) => schema.evidenceChunks.find((chunk) => chunk.stableEvidenceId === id)).filter((chunk) => chunk !== undefined).map((chunk) => ({
+      stableEvidenceId: chunk.stableEvidenceId,
+      method: chunk.method,
+      source: chunk.source,
+      ...chunk.excerpt !== undefined ? { excerpt: chunk.excerpt } : {},
+      ...chunk.content !== undefined ? { content: chunk.content } : {},
+      ...chunk.retrievalResultId !== undefined ? { retrievalResultId: chunk.retrievalResultId } : {},
+      ...chunk.chunkIndex !== undefined ? { chunkIndex: chunk.chunkIndex } : {},
+      ...chunk.lineNumber !== undefined ? { lineNumber: chunk.lineNumber } : {},
+      ...chunk.metadata !== undefined ? { metadata: chunk.metadata } : {}
+    }));
+    return {
+      number: result.number,
+      title: result.title,
+      summary: result.summary,
+      chunks
+    };
+  });
+  return { sessionId, results };
+}
+function renderEvidence(view, json) {
+  if (json)
+    return JSON.stringify(view, null, 2);
+  const lines = [`session: ${view.sessionId}`];
+  for (const result of view.results) {
+    lines.push(`[${result.number}] ${result.title}`);
+    for (const chunk of result.chunks) {
+      lines.push(`  source: ${chunk.source}`);
+      lines.push(`  method: ${chunk.method}`);
+      lines.push(`  evidenceId: ${chunk.stableEvidenceId}`);
+      if (chunk.chunkIndex !== undefined)
+        lines.push(`  chunkIndex: ${chunk.chunkIndex}`);
+      if (chunk.lineNumber !== undefined)
+        lines.push(`  lineNumber: ${chunk.lineNumber}`);
+      if (chunk.excerpt !== undefined)
+        lines.push(`  excerpt: ${chunk.excerpt}`);
+      if (chunk.content !== undefined)
+        lines.push(`  content: ${chunk.content}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+async function runEvidence(ctx) {
+  const sessionId = ctx.positionals[0]?.trim();
+  if (!sessionId) {
+    ctx.stderr(renderError(new Error("Usage: autorag evidence <sessionId> [--result N]"), { json: ctx.json }));
+    return 2;
+  }
+  try {
+    const config = resolveConfig({ flags: ctx.flags, cwd: ctx.cwd });
+    const memory = new RetrievalMemory({ storagePath: config.memoryPath });
+    memory.load();
+    const view = evidenceFor(memory.getSchema(), sessionId, parseResultNumber(ctx.flags.result));
+    if (view.results.length === 0) {
+      ctx.stderr(renderError(new Error(`No evidence found for session ${sessionId}.`), { json: ctx.json }));
+      return 2;
+    }
+    ctx.stdout(renderEvidence(view, ctx.json));
+    return 0;
+  } catch (error) {
+    ctx.stderr(renderError(error, { json: ctx.json }));
+    return 1;
+  }
+}
+var init_evidence = __esm(() => {
+  init_memory();
+  init_config2();
 });
+
+// src/cli/commands/memory.ts
 async function runMemory(ctx) {
   const subcommand = ctx.positionals[0];
   if (subcommand !== "inspect") {
@@ -15507,12 +15270,8 @@ var init_memory2 = __esm(() => {
 });
 
 // src/cli/commands/index.ts
-var exports_commands = {};
-__export(exports_commands, {
-  runIndex: () => runIndex
-});
-import { existsSync as existsSync17, lstatSync as lstatSync3, rmSync as rmSync7 } from "node:fs";
-import { join as join23, resolve as resolve12, sep as sep5 } from "node:path";
+import { existsSync as existsSync16, lstatSync as lstatSync3, rmSync as rmSync6 } from "node:fs";
+import { join as join22, resolve as resolve12, sep as sep5 } from "node:path";
 async function runIndex(ctx) {
   const sub = ctx.positionals[0];
   if (sub !== "reset" && sub !== "rebuild") {
@@ -15531,7 +15290,7 @@ async function runIndex(ctx) {
   const autoragDir = resolve12(config.workspacePath, ".autorag");
   const targets = targetSubdirs.map((subdir) => resolve12(config.workspacePath, subdir));
   for (const dir of [autoragDir, ...targets]) {
-    if (existsSync17(dir) && lstatSync3(dir).isSymbolicLink()) {
+    if (existsSync16(dir) && lstatSync3(dir).isSymbolicLink()) {
       ctx.stderr(renderError(new Error("Refusing to reset: an index path is a symlink, not a real directory."), {
         json: ctx.json
       }));
@@ -15546,8 +15305,8 @@ async function runIndex(ctx) {
   }
   if (!ctx.flags.yes) {
     if (ctx.promptYesNo) {
-      const ok6 = await ctx.promptYesNo(`Reset the ${targetNames.join(", ")} indexes under ${join23(config.workspacePath, ".autorag")}?`);
-      if (!ok6) {
+      const ok = await ctx.promptYesNo(`Reset the ${targetNames.join(", ")} indexes under ${join22(config.workspacePath, ".autorag")}?`);
+      if (!ok) {
         ctx.stderr(renderError(new Error("Reset declined."), { json: ctx.json }));
         return 2;
       }
@@ -15557,7 +15316,7 @@ async function runIndex(ctx) {
     }
   }
   for (const target of targets) {
-    rmSync7(target, { recursive: true, force: true });
+    rmSync6(target, { recursive: true, force: true });
   }
   if (sub === "reset") {
     ctx.stdout(renderIndex({ action: "reset", removed: [...targetNames] }, { json: ctx.json }));
@@ -15595,11 +15354,8 @@ function resolveResetScope(methods) {
     refresh.push(m);
     if (m === "parsed") {
       addTarget("parsed", PARSED_MIRROR_SUBDIR);
-    } else if (m === "bm25") {
-      addTarget("bm25", BM25_SUBDIR);
     } else if (m === "minsync") {
       addTarget("minsync", MINSYNC_SUBDIR);
-      addTarget("bm25", BM25_SUBDIR);
     }
   }
   return {
@@ -15617,18 +15373,13 @@ var init_commands = __esm(() => {
   init_agent();
   init_paths4();
   init_paths();
-  init_bm25();
   init_config2();
   init_refresh();
-  ALL_RESET_TARGETS = [PARSED_MIRROR_SUBDIR, MINSYNC_SUBDIR, BM25_SUBDIR];
-  ALL_RESET_TARGET_NAMES = ["parsed", "minsync", "bm25"];
+  ALL_RESET_TARGETS = [PARSED_MIRROR_SUBDIR, MINSYNC_SUBDIR];
+  ALL_RESET_TARGET_NAMES = ["parsed", "minsync"];
 });
 
 // src/cli/commands/watch.ts
-var exports_watch = {};
-__export(exports_watch, {
-  runWatch: () => runWatch
-});
 function parsePositiveInt(value, fallback) {
   if (typeof value !== "string" || value.trim().length === 0)
     return fallback;
@@ -15665,14 +15416,14 @@ async function runWatch(ctx) {
       ...started,
       message: "watching for source changes; send SIGINT/SIGTERM to stop"
     }) : `AutoRAG watch started (roots=${started.roots}, debounceMs=${debounceMs}). Ctrl-C to stop.`);
-    await new Promise((resolve13) => {
+    await new Promise((resolve) => {
       let stopped = false;
       const stop = () => {
         if (stopped)
           return;
         stopped = true;
         handle.stop();
-        resolve13();
+        resolve();
       };
       process.once("SIGINT", stop);
       process.once("SIGTERM", stop);
@@ -15694,10 +15445,6 @@ var init_watch = __esm(() => {
 });
 
 // src/cli/commands/health.ts
-var exports_health = {};
-__export(exports_health, {
-  runHealth: () => runHealth
-});
 import { completeSimple } from "@earendil-works/pi-ai/compat";
 function sanitizeMessage(raw) {
   let out = raw.split(/\n\s+at\s/)[0] ?? raw;
@@ -15709,7 +15456,7 @@ function sanitizeMessage(raw) {
 function parseTimeoutMs(flags) {
   const raw = flags["timeout-ms"];
   if (raw === undefined || raw === true)
-    return DEFAULT_TIMEOUT_MS10;
+    return DEFAULT_TIMEOUT_MS9;
   const text = typeof raw === "string" ? raw.trim() : "";
   if (!/^\d+$/.test(text) || Number(text) <= 0) {
     return `--timeout-ms must be a positive integer (got "${text}")`;
@@ -15795,7 +15542,7 @@ async function runHealth(ctx, deps = {}) {
     indexHealth: { separate: true, command: "autorag status", included: false }
   };
   if (typeof timeout === "string") {
-    const report2 = {
+    const report = {
       ...base,
       ok: false,
       category: "config",
@@ -15803,14 +15550,14 @@ async function runHealth(ctx, deps = {}) {
       coverage: coverage(),
       config: { ok: false, source: "defaults", message: timeout }
     };
-    ctx.stdout(renderHealth(report2, { json: ctx.json, debug: ctx.debug }));
+    ctx.stdout(renderHealth(report, { json: ctx.json, debug: ctx.debug }));
     return 2;
   }
   let config;
   try {
     config = (deps.configResolver ?? resolveConfigReadOnly)({ flags: ctx.flags, cwd: ctx.cwd });
   } catch (error) {
-    const report2 = {
+    const report = {
       ...base,
       ok: false,
       category: "config",
@@ -15818,7 +15565,7 @@ async function runHealth(ctx, deps = {}) {
       coverage: coverage(),
       config: { ok: false, source: "defaults", message: sanitizeMessage(String(error)) }
     };
-    ctx.stdout(renderHealth(report2, { json: ctx.json, debug: ctx.debug }));
+    ctx.stdout(renderHealth(report, { json: ctx.json, debug: ctx.debug }));
     return 2;
   }
   let resolved;
@@ -15826,7 +15573,7 @@ async function runHealth(ctx, deps = {}) {
     const detailed = (deps.modelResolver ?? resolveAgentModelDetailed)(config);
     resolved = detailed;
   } catch (error) {
-    const report2 = {
+    const report = {
       ...base,
       ok: false,
       category: "model_resolution",
@@ -15840,12 +15587,12 @@ async function runHealth(ctx, deps = {}) {
         message: sanitizeMessage(error instanceof Error ? error.message : String(error))
       }
     };
-    ctx.stdout(renderHealth(report2, { json: ctx.json, debug: ctx.debug }));
+    ctx.stdout(renderHealth(report, { json: ctx.json, debug: ctx.debug }));
     return 2;
   }
   const model = roleReport(resolved.role);
   if (!resolved.role.auth.present) {
-    const report2 = {
+    const report = {
       ...base,
       ok: false,
       category: "auth_missing",
@@ -15855,11 +15602,11 @@ async function runHealth(ctx, deps = {}) {
       model,
       probe: { skipped: true, ok: false, category: "auth_missing" }
     };
-    ctx.stdout(renderHealth(report2, { json: ctx.json, debug: ctx.debug }));
+    ctx.stdout(renderHealth(report, { json: ctx.json, debug: ctx.debug }));
     return 1;
   }
   if (ctx.flags["skip-probes"] === true) {
-    const report2 = {
+    const report = {
       ...base,
       ok: true,
       category: "ok",
@@ -15869,7 +15616,7 @@ async function runHealth(ctx, deps = {}) {
       model,
       probe: { skipped: true, ok: false, category: "ok" }
     };
-    ctx.stdout(renderHealth(report2, { json: ctx.json, debug: ctx.debug }));
+    ctx.stdout(renderHealth(report, { json: ctx.json, debug: ctx.debug }));
     return 0;
   }
   const probe = await runProbe(deps.probe ?? defaultProbe, {
@@ -15892,16 +15639,12 @@ async function runHealth(ctx, deps = {}) {
   ctx.stdout(renderHealth(report, { json: ctx.json, debug: ctx.debug }));
   return exitCode(probe.category);
 }
-var DEFAULT_TIMEOUT_MS10 = 1e4;
+var DEFAULT_TIMEOUT_MS9 = 1e4;
 var init_health = __esm(() => {
   init_config2();
 });
 
 // src/cli/commands/duplicates.ts
-var exports_duplicates = {};
-__export(exports_duplicates, {
-  runDuplicates: () => runDuplicates
-});
 import { resolve as resolve13 } from "node:path";
 async function runDuplicates(ctx, scanner = (path) => scanWithDupey(path)) {
   try {
@@ -15997,14 +15740,14 @@ function renderSlashHelp() {
 }
 
 // src/cli/tui-session-store.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync14, readFileSync as readFileSync15, renameSync as renameSync8, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname16 } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync13, readFileSync as readFileSync14, renameSync as renameSync8, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname15 } from "node:path";
 function createFileTuiSessionStore(path) {
   const readSessions = () => {
-    if (!existsSync18(path))
+    if (!existsSync17(path))
       return [];
     try {
-      const parsed = JSON.parse(readFileSync15(path, "utf8"));
+      const parsed = JSON.parse(readFileSync14(path, "utf8"));
       if (!Array.isArray(parsed))
         return [];
       return parsed.filter(isTuiSessionRecord).sort((a, b) => b.updatedAt - a.updatedAt);
@@ -16018,10 +15761,10 @@ function createFileTuiSessionStore(path) {
     save: (session) => {
       const sessions = readSessions().filter((item) => item.id !== session.id);
       sessions.unshift(session);
-      const dir = dirname16(path);
-      mkdirSync14(dir, { recursive: true });
+      const dir = dirname15(path);
+      mkdirSync13(dir, { recursive: true });
       const tmpPath = `${path}.${process.pid}.tmp`;
-      writeFileSync12(tmpPath, `${JSON.stringify(sessions.slice(0, MAX_SESSIONS), null, 2)}
+      writeFileSync11(tmpPath, `${JSON.stringify(sessions.slice(0, MAX_SESSIONS), null, 2)}
 `, "utf8");
       renameSync8(tmpPath, path);
     }
@@ -16075,14 +15818,7 @@ var MAX_SESSIONS = 100;
 var init_tui_session_store = () => {};
 
 // src/cli/commands/tui.ts
-var exports_tui = {};
-__export(exports_tui, {
-  createTuiPresenter: () => createTuiPresenter,
-  parseSlashCommand: () => parseSlashCommand,
-  renderTuiSessionView: () => renderTuiSessionView,
-  runTui: () => runTui
-});
-import { join as join24 } from "node:path";
+import { join as join23 } from "node:path";
 import {
   CombinedAutocompleteProvider,
   Editor,
@@ -16207,6 +15943,26 @@ function createTuiPresenter() {
 function dimGray(text) {
   return `${ANSI_DIM_GRAY}${text}${ANSI_RESET}`;
 }
+function renderProgressEvent(event) {
+  return event.type === "progress" && event.text.trim() !== "" ? event.text : undefined;
+}
+async function consumeSearchStream(agent, query, handlers) {
+  for await (const event of agent.searchDocumentsStream(query)) {
+    if (handlers.isInterrupted?.())
+      return;
+    switch (event.type) {
+      case "progress": {
+        const progress = renderProgressEvent(event);
+        if (progress !== undefined)
+          handlers.onProgress(progress);
+        break;
+      }
+      case "complete":
+        handlers.onComplete(event.response);
+        break;
+    }
+  }
+}
 function stripAnsi(text) {
   return text.replace(/\u001b\[[0-9;]*m/g, "");
 }
@@ -16241,8 +15997,8 @@ ${content}`;
 }
 function defaultSessionStore(ctx) {
   const config = resolveConfig({ flags: ctx.flags, cwd: ctx.cwd });
-  const workspace = createFileTuiSessionStore(join24(config.workspacePath, ".autorag", "tui-sessions.json"));
-  const global = createFileTuiSessionStore(join24(resolveAutoRAGHome(), "tui-sessions.json"));
+  const workspace = createFileTuiSessionStore(join23(config.workspacePath, ".autorag", "tui-sessions.json"));
+  const global = createFileTuiSessionStore(join23(resolveAutoRAGHome(), "tui-sessions.json"));
   return createMergedTuiSessionStore(workspace, global);
 }
 function runRealTui(ctx, agent, store) {
@@ -16265,7 +16021,7 @@ ${trace.join(`
 `));
   };
   const status = new Text(presenter.status());
-  const renderStatus2 = () => {
+  const renderStatus = () => {
     status.setText(presenter.status());
   };
   const editor = new Editor(tui, {
@@ -16285,18 +16041,18 @@ ${trace.join(`
   let resumeSelection = false;
   let completedResponse;
   let completedAnswer = "";
-  return new Promise((resolve14) => {
+  return new Promise((resolve) => {
     const finish = () => {
       if (settled)
         return;
       settled = true;
       unsubscribe?.();
       tui.stop();
-      resolve14(0);
+      resolve(0);
     };
     const unsubscribe = agent.subscribe?.((event) => {
       presenter.handle(event);
-      renderStatus2();
+      renderStatus();
       renderTranscript();
       tui.requestRender();
     });
@@ -16313,7 +16069,7 @@ interrupted`;
           transcriptHistory = `${transcriptHistory}
 paused`;
         }
-        renderStatus2();
+        renderStatus();
         renderTranscript();
         tui.requestRender();
         return;
@@ -16373,23 +16129,30 @@ ${renderTuiSessionList(store.list())}`;
       presenter.beginRun();
       editor.disableSubmit = true;
       presenter.setWorking(true);
-      renderStatus2();
+      renderStatus();
       finalAnswer = "";
       transcriptHistory = `${transcriptHistory}
 
-> ${query}
-search: preparing retrieval`;
+> ${query}`;
       renderTranscript();
       tui.requestRender();
-      agent.searchDocuments(query).then((response) => {
-        const answer = renderSearch(response, {
-          json: false,
-          debug: ctx.debug
-        });
-        completedResponse = response;
-        completedAnswer = answer;
-        finalAnswer = answer;
-        renderTranscript();
+      consumeSearchStream(agent, query, {
+        onProgress: (progress) => {
+          transcriptHistory = `${transcriptHistory}
+
+${progress}`;
+          renderTranscript();
+          tui.requestRender();
+        },
+        onComplete: (response) => {
+          const answer = renderSearch(response, { json: false, debug: ctx.debug });
+          completedResponse = response;
+          completedAnswer = answer;
+          finalAnswer = answer;
+          renderTranscript();
+          tui.requestRender();
+        },
+        isInterrupted: () => interrupted
       }).catch((error) => {
         if (interrupted)
           return;
@@ -16403,7 +16166,7 @@ ${renderError(error, {
       }).finally(() => {
         queryRunning = false;
         presenter.setWorking(false);
-        renderStatus2();
+        renderStatus();
         if (completedResponse !== undefined) {
           store.save({
             id: completedResponse.sessionId,
@@ -16490,13 +16253,18 @@ async function runTui(ctx, deps = {}) {
       interrupted = false;
       presenter.beginRun();
       try {
-        const response = await agent.searchDocuments(query);
-        if (!interrupted) {
-          const answer = renderSearch(response, { json: false, debug: ctx.debug });
-          tui.rendered.push(answer);
-          completedResponse = response;
-          completedAnswer = answer;
-        }
+        await consumeSearchStream(agent, query, {
+          onProgress: (progress) => {
+            tui.rendered.push(progress);
+          },
+          onComplete: (response) => {
+            const answer = renderSearch(response, { json: false, debug: ctx.debug });
+            tui.rendered.push(answer);
+            completedResponse = response;
+            completedAnswer = answer;
+          },
+          isInterrupted: () => interrupted
+        });
       } catch (error) {
         if (!interrupted) {
           tui.rendered.push(renderError(error, { json: false, debug: ctx.debug }));
@@ -16553,20 +16321,20 @@ var init_tui = __esm(() => {
 });
 
 // src/ui/browse.ts
-import { existsSync as existsSync19, readdirSync as readdirSync4, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync18, readdirSync as readdirSync4, statSync as statSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname17, join as join25, resolve as resolve14 } from "node:path";
+import { dirname as dirname16, join as join24, resolve as resolve14 } from "node:path";
 function browseDirectory(inputPath) {
   const path = resolve14(inputPath && inputPath.trim().length > 0 ? inputPath : homedir3());
-  if (!existsSync19(path))
+  if (!existsSync18(path))
     throw new ConfigError("Folder was not found.");
-  let stat5;
+  let stat;
   try {
-    stat5 = statSync2(path);
+    stat = statSync2(path);
   } catch {
     throw new ConfigError("Folder was not found.");
   }
-  if (!stat5.isDirectory())
+  if (!stat.isDirectory())
     throw new ConfigError("Path is not a folder.");
   let names = [];
   try {
@@ -16578,7 +16346,7 @@ function browseDirectory(inputPath) {
   for (const name of names) {
     if (name === "." || name === "..")
       continue;
-    const child = join25(path, name);
+    const child = join24(path, name);
     let directory = false;
     try {
       directory = statSync2(child).isDirectory();
@@ -16590,7 +16358,7 @@ function browseDirectory(inputPath) {
       break;
   }
   entries.sort((a, b) => Number(b.directory) - Number(a.directory) || a.name.localeCompare(b.name));
-  const parent = dirname17(path);
+  const parent = dirname16(path);
   return {
     path,
     parent: parent === path ? null : parent,
@@ -16758,21 +16526,11 @@ var init_catalog = __esm(() => {
     },
     {
       type: "gmail",
-      title: "Gmail / IMAP",
-      summary: "Gmail API via a token env var, or any IMAP account through himalaya.",
+      title: "Gmail",
+      summary: "Search Gmail through the Gmail API.",
       defaultTags: ["gmail", "email", "pii"],
-      binaryName: "himalaya",
       fields: [
         INSTANCE,
-        {
-          key: "connector.backend",
-          label: "Backend",
-          kind: "select",
-          options: [
-            { value: "", label: "Gmail API (token env)" },
-            { value: "himalaya", label: "himalaya (IMAP)" }
-          ]
-        },
         {
           key: "connector.tokenEnv",
           label: "Access token environment variable",
@@ -16785,10 +16543,7 @@ var init_catalog = __esm(() => {
           kind: "textarea",
           placeholder: "INBOX",
           help: "One label id per line."
-        },
-        { key: "connector.account", label: "himalaya account", kind: "text" },
-        { key: "connector.folder", label: "Mail folder", kind: "text", placeholder: "INBOX" },
-        BINARY
+        }
       ]
     },
     {
@@ -16950,16 +16705,7 @@ var init_catalog = __esm(() => {
         question: "Which rclone remote (Google Drive, OneDrive, …) should this connection use?"
       }
     ],
-    gmail: [
-      {
-        key: "account",
-        label: "Mailbox",
-        kind: "select",
-        choices: "mail-accounts",
-        allowOther: true,
-        question: "Which email account should this connection use (Gmail, Outlook, iCloud, or another IMAP mailbox)?"
-      }
-    ],
+    gmail: [],
     "mail-export": [
       {
         key: "paths",
@@ -17023,18 +16769,21 @@ var init_catalog = __esm(() => {
 });
 
 // src/ui/probe.ts
-import { existsSync as existsSync20 } from "node:fs";
-import { delimiter as delimiter3, join as join26 } from "node:path";
+import { existsSync as existsSync19 } from "node:fs";
+import { delimiter as delimiter3, join as join25 } from "node:path";
 function probeConnection(input, deps = {}) {
   const catalog = getDatasourceType(input.type);
   if (catalog === undefined) {
     return { ok: false, status: "unknown-type", detail: `Unknown datasource type: ${input.type}` };
   }
   const env = deps.env ?? process.env;
-  const pathExists = deps.pathExists ?? existsSync20;
+  const pathExists = deps.pathExists ?? existsSync19;
   const binaryExists = deps.binaryExists ?? defaultBinaryExists;
   const connector = input.connector ?? {};
   const fail = (status, detail) => ({ ok: false, status, detail });
+  if (input.type === "gmail" && connector.backend === "himalaya") {
+    return fail("not-configured", "Himalaya-backed mail must be configured through the mailcrawl datasource.");
+  }
   if (input.type === "github") {
     const repos = asStringList(connector.repos);
     if (repos.length === 0)
@@ -17082,12 +16831,6 @@ function probeConnection(input, deps = {}) {
     return ok6("Queries saved.");
   }
   if (input.type === "gmail") {
-    if (connector.backend === "himalaya") {
-      if (!binaryExists("himalaya", asString4(connector.binaryPath))) {
-        return fail("binary-missing", "himalaya is not installed.");
-      }
-      return ok6("himalaya will use its own account config.");
-    }
     const tokenEnv = envName(connector.tokenEnv, "GMAIL_ACCESS_TOKEN");
     if (!envHas(env, tokenEnv))
       return fail("auth-missing", `${tokenEnv} is not set in the environment.`);
@@ -17152,14 +16895,14 @@ function asFeedUrls(value) {
 }
 function defaultBinaryExists(binaryName, binaryPath) {
   if (binaryPath !== undefined && binaryPath.length > 0)
-    return existsSync20(binaryPath);
+    return existsSync19(binaryPath);
   const pathEnv = process.env.PATH ?? "";
   const extensions = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
   for (const dir of pathEnv.split(delimiter3)) {
     if (dir.length === 0)
       continue;
     for (const extension of extensions) {
-      if (existsSync20(join26(dir, `${binaryName}${extension}`)))
+      if (existsSync19(join25(dir, `${binaryName}${extension}`)))
         return true;
     }
   }
@@ -17188,6 +16931,9 @@ function upsertConnection(configPath, input) {
   const raw = readRawConfigObject(configPath);
   const datasources = asObject(raw.datasources);
   const connector = normalizeConnector(type, stripSecrets(input.connector ?? {}));
+  if (isRetiredGmailHimalaya(type, connector)) {
+    throw new ConfigError("Himalaya-backed mail must use the mailcrawl datasource.");
+  }
   const enabled = input.enabled !== false;
   const entry = {
     type,
@@ -17214,6 +16960,12 @@ function toggleConnection(configPath, alias, enabled) {
   if (current === false || current === true) {
     datasources[alias] = { type: alias, enabled };
   } else if (typeof current === "object" && current !== null && !Array.isArray(current)) {
+    const currentEntry = asObject(current);
+    const currentType = typeof currentEntry.type === "string" && currentEntry.type.length > 0 ? currentEntry.type : alias;
+    const currentConnector = asObject(currentEntry.connector);
+    if (isRetiredGmailHimalaya(currentType, currentConnector)) {
+      throw new ConfigError("Himalaya-backed mail must use the mailcrawl datasource.");
+    }
     datasources[alias] = { ...current, enabled };
   } else {
     throw new ConfigError(`Unknown connection: ${alias}`);
@@ -17281,7 +17033,7 @@ function readConnections(raw) {
     const entry = value;
     const type = typeof entry.type === "string" && entry.type.length > 0 ? entry.type : alias;
     const connector = stripSecrets(asObject(entry.connector));
-    const enabled = entry.enabled !== false;
+    const enabled = entry.enabled !== false && !isRetiredGmailHimalaya(type, connector);
     connections.push({
       alias,
       type,
@@ -17302,6 +17054,9 @@ function tagsFor(type, connector) {
   }
   return tags;
 }
+function isRetiredGmailHimalaya(type, connector) {
+  return type === "gmail" && connector.backend === "himalaya";
+}
 function normalizeAlias(alias) {
   const trimmed = alias.trim();
   if (!ALIAS_PATTERN.test(trimmed)) {
@@ -17423,55 +17178,32 @@ var init_config_store = __esm(() => {
 });
 
 // src/ui/discover.ts
-import { spawn as spawn15 } from "node:child_process";
+import { spawn as spawn14 } from "node:child_process";
 async function listRcloneRemotes(run = runCli) {
   const result = await run("rclone", ["listremotes"]);
   if (!result.ok)
     return [];
   return result.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map((value) => ({ value, label: value }));
 }
-async function listMailAccounts(run = runCli) {
-  const discovered = await listHimalayaAccounts(run);
-  const seen = new Set(discovered.map((item) => item.value.toLowerCase()));
-  const presets = MAIL_PRESETS.filter((item) => !seen.has(item.value.toLowerCase()) && !seen.has(item.label.toLowerCase()));
-  return [...discovered, ...presets, { value: "other", label: "Other…" }];
-}
-async function listHimalayaAccounts(run = runCli) {
-  const result = await run("himalaya", ["account", "list"]);
-  if (!result.ok)
-    return [];
-  const choices = [];
-  for (const raw of result.stdout.split(/\r?\n/)) {
-    const line = raw.replace(/^\s*[*-]\s*/, "").trim();
-    if (line.length === 0 || line.toLowerCase().startsWith("account") || line.startsWith("─") || line.startsWith("-")) {
-      continue;
-    }
-    const name = line.split(/\s{2,}|\t/)[0]?.trim();
-    if (name && name !== "NAME" && name !== "Name")
-      choices.push({ value: name, label: name });
-  }
-  return choices;
-}
 async function choicesForType(type, run = runCli) {
   if (type === "cloud-drive") {
     return { rcloneRemotes: await listRcloneRemotes(run), mailAccounts: [] };
   }
-  if (type === "gmail") {
-    return { rcloneRemotes: [], mailAccounts: await listMailAccounts(run) };
-  }
+  if (type === "gmail")
+    return { rcloneRemotes: [], mailAccounts: [] };
   return { rcloneRemotes: [], mailAccounts: [] };
 }
 function runCli(binary, args) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve) => {
     let settled = false;
-    const child = spawn15(binary, [...args], { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn14(binary, [...args], { stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
-    const finish = (ok7) => {
+    const finish = (ok) => {
       if (settled)
         return;
       settled = true;
       clearTimeout(timer);
-      resolve15({ ok: ok7, stdout: Buffer.concat(chunks).toString("utf8") });
+      resolve({ ok, stdout: Buffer.concat(chunks).toString("utf8") });
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
@@ -17484,14 +17216,7 @@ function runCli(binary, args) {
     child.on("close", (code) => finish(code === 0));
   });
 }
-var MAIL_PRESETS;
-var init_discover = __esm(() => {
-  MAIL_PRESETS = [
-    { value: "gmail", label: "Gmail" },
-    { value: "outlook", label: "Outlook" },
-    { value: "icloud", label: "iCloud" }
-  ];
-});
+var init_discover = () => {};
 
 // src/ui/html.ts
 function renderUiPage(state) {
@@ -17576,7 +17301,7 @@ function renderUiPage(state) {
   <section class="card">
     <label for="folders">Folders to search</label>
     <textarea id="folders">${folders}</textarea>
-    <p class="help">BM25, MinSync, and Jikji index these folders by default. One absolute path per line.</p>
+    <p class="help">MinSync and Jikji index these folders by default. One absolute path per line.</p>
     <div class="row actions"><button type="button" class="primary" id="save-folders">Save folders</button></div>
   </section>
 
@@ -17887,8 +17612,8 @@ async function startUiServer(options) {
     host: boundHost === "[::1]" ? "::1" : boundHost,
     port: address.port,
     token,
-    close: () => new Promise((resolve15, reject) => {
-      httpServer.close((error) => error ? reject(error) : resolve15());
+    close: () => new Promise((resolve, reject) => {
+      httpServer.close((error) => error ? reject(error) : resolve());
     })
   };
 }
@@ -18130,7 +17855,7 @@ function parseExtras(raw) {
   }
 }
 function listen(server, port, host) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve, reject) => {
     const onError = (error) => {
       server.off("error", onError);
       reject(error);
@@ -18138,7 +17863,7 @@ function listen(server, port, host) {
     server.once("error", onError);
     server.listen(port, host, () => {
       server.off("error", onError);
-      resolve15();
+      resolve();
     });
   });
 }
@@ -18153,18 +17878,13 @@ var init_server = __esm(() => {
 });
 
 // src/cli/commands/ui.ts
-var exports_ui = {};
-__export(exports_ui, {
-  openBrowser: () => openBrowser,
-  runUi: () => runUi
-});
-import { spawn as spawn16 } from "node:child_process";
+import { spawn as spawn15 } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync21 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 async function runUi(ctx, deps = {}) {
   const flags = ctx.flags;
   const resolved = resolveConfigPath({ flags, cwd: ctx.cwd });
-  if (!existsSync21(resolved.configPath)) {
+  if (!existsSync20(resolved.configPath)) {
     ctx.stderr(renderError(new ConfigError(`Config file not found: ${resolved.configPath}. Run autorag init first.`), {
       json: ctx.json
     }));
@@ -18240,13 +17960,13 @@ async function runUi(ctx, deps = {}) {
   }
 }
 async function defaultWaitUntilStopped(server) {
-  await new Promise((resolve15) => {
+  await new Promise((resolve) => {
     let stopped = false;
     const stop = () => {
       if (stopped)
         return;
       stopped = true;
-      server.close().finally(resolve15);
+      server.close().finally(resolve);
     };
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
@@ -18255,7 +17975,7 @@ async function defaultWaitUntilStopped(server) {
 async function openBrowser(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  spawn16(command, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
+  spawn15(command, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
 }
 var init_ui = __esm(() => {
   init_server();
@@ -18288,6 +18008,7 @@ var VALUE_FLAGS = new Set([
   "top-k",
   "scope",
   "tags",
+  "result",
   "useful",
   "not-useful",
   "debounce-ms",
@@ -18311,6 +18032,7 @@ var COMMANDS = [
   "status",
   "search",
   "feedback",
+  "evidence",
   "memory",
   "index",
   "watch",
@@ -18330,14 +18052,15 @@ Commands:
 	                        --embedder-id ID --embedder-base-url URL --embedder-api-key-env VAR
 	                       --embedder-dimension N --embedder-batch-size N
 	                       --minsync-max-chunk-size N  --force)
-  refresh              Parse sources and refresh indexes (--method bm25,minsync,parsed)
+  refresh              Refresh every configured index; --method narrows the run
   watch                Watch configured roots (or --once for cron/poll tick)
   status               Show corpus freshness and index health
   search <query>       Search and curate documents (requires a configured model)
   feedback <session>   Record numbered feedback (--useful 1,3 --not-useful 2)
+  evidence <session>   Show persisted source/chunk evidence (--result N)
   memory inspect       Inspect the retrieval memory snapshot
-  index reset          Remove parsed/minsync indexes and leftover .autorag/bm25 (--method)
-  index rebuild        Reset then re-run a refresh (--method bm25|minsync|all)
+  index reset          Remove parsed/minsync indexes (--method)
+  index rebuild        Reset then re-run a refresh (--method minsync|all)
   health               Check model/provider auth and completion access (no index check)
   duplicates [DIR]     Scan exact/near duplicate document families; never deletes files
   tui                  Open an interactive Pi-powered librarian terminal UI
@@ -18346,7 +18069,7 @@ Commands:
 
 Setup:
   autorag init --search-paths /path/to/docs,/path/to/notes   # choose folders
-  autorag refresh                                            # parse + index (+ jikji prepare)
+  autorag refresh                                            # parsed + MinSync + datasources + Jikji
   autorag watch --once                                       # single index refresh tick (cron)
   autorag search "your question"                             # curated answer
 
@@ -18360,7 +18083,7 @@ Global flags:
   --once               For watch: run one refresh tick and exit (for cron)
   --immediate          For watch: refresh once before reading fs events (default true)
   --debounce-ms <n>    For watch: debounce milliseconds for fs events (default 1500)
-  --method <csv>       For refresh/index: bm25,minsync,parsed,datasources,jikji,all
+  --method <csv>       For refresh/index: minsync,parsed,datasources,jikji,all
   --skip-probes        For health: skip the network completion probe (auth checks still run)
   --timeout-ms <n>     For health: per-probe timeout in ms (default 10000)
   --port <n>           For ui: loopback port (default 8787, 0 for ephemeral)
@@ -18406,62 +18129,66 @@ function parseArgs(argv) {
 }
 function promptYesNo(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve15) => {
+  return new Promise((resolve) => {
     rl.question(`${question} [y/N] `, (answer) => {
       rl.close();
-      resolve15(/^y(es)?$/i.test(answer.trim()));
+      resolve(/^y(es)?$/i.test(answer.trim()));
     });
   });
 }
 async function dispatch(command, ctx) {
   switch (command) {
     case "init": {
-      const { runInit: runInit2 } = await Promise.resolve().then(() => (init_init(), exports_init));
-      return runInit2(ctx);
+      await Promise.resolve().then(() => init_init());
+      return runInit(ctx);
     }
     case "refresh": {
-      const { runRefresh: runRefresh2 } = await Promise.resolve().then(() => (init_refresh(), exports_refresh));
-      return runRefresh2(ctx);
+      await Promise.resolve().then(() => init_refresh());
+      return runRefresh(ctx);
     }
     case "status": {
-      const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), exports_status));
-      return runStatus2(ctx);
+      await Promise.resolve().then(() => init_status());
+      return runStatus(ctx);
     }
     case "search": {
-      const { runSearch: runSearch2 } = await Promise.resolve().then(() => (init_search(), exports_search));
-      return runSearch2(ctx);
+      await Promise.resolve().then(() => init_search());
+      return runSearch(ctx);
     }
     case "feedback": {
-      const { runFeedback: runFeedback2 } = await Promise.resolve().then(() => (init_feedback(), exports_feedback));
-      return runFeedback2(ctx);
+      await Promise.resolve().then(() => init_feedback());
+      return runFeedback(ctx);
+    }
+    case "evidence": {
+      await Promise.resolve().then(() => init_evidence());
+      return runEvidence(ctx);
     }
     case "memory": {
-      const { runMemory: runMemory2 } = await Promise.resolve().then(() => (init_memory2(), exports_memory));
-      return runMemory2(ctx);
+      await Promise.resolve().then(() => init_memory2());
+      return runMemory(ctx);
     }
     case "index": {
-      const { runIndex: runIndex2 } = await Promise.resolve().then(() => (init_commands(), exports_commands));
-      return runIndex2(ctx);
+      await Promise.resolve().then(() => init_commands());
+      return runIndex(ctx);
     }
     case "watch": {
-      const { runWatch: runWatch2 } = await Promise.resolve().then(() => (init_watch(), exports_watch));
-      return runWatch2(ctx);
+      await Promise.resolve().then(() => init_watch());
+      return runWatch(ctx);
     }
     case "health": {
-      const { runHealth: runHealth2 } = await Promise.resolve().then(() => (init_health(), exports_health));
-      return runHealth2(ctx);
+      await Promise.resolve().then(() => init_health());
+      return runHealth(ctx);
     }
     case "duplicates": {
-      const { runDuplicates: runDuplicates2 } = await Promise.resolve().then(() => (init_duplicates(), exports_duplicates));
-      return runDuplicates2(ctx);
+      await Promise.resolve().then(() => init_duplicates());
+      return runDuplicates(ctx);
     }
     case "tui": {
-      const { runTui: runTui2 } = await Promise.resolve().then(() => (init_tui(), exports_tui));
-      return runTui2(ctx);
+      await Promise.resolve().then(() => init_tui());
+      return runTui(ctx);
     }
     case "ui": {
-      const { runUi: runUi2 } = await Promise.resolve().then(() => (init_ui(), exports_ui));
-      return runUi2(ctx);
+      await Promise.resolve().then(() => init_ui());
+      return runUi(ctx);
     }
   }
 }