@autorag/librarian 2.4.0 → 2.4.1

package/dist/index.js

@@ -1,20 +1,14 @@
-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/config/home.ts
 import { homedir } from "node:os";
@@ -844,6 +838,7 @@ var init_installer = __esm(() => {
 // src/jikji/client.ts
 import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
+import { join as join5 } from "node:path";
 
 class JikjiClient {
   options;
@@ -851,6 +846,9 @@ class JikjiClient {
   constructor(options = {}) {
     this.options = options;
   }
+  isPrepared(root) {
+    return existsSync4(join5(root, ".jikji", "doc_meta")) || existsSync4(join5(root, ".jikji", "doc_text"));
+  }
   async resolveCommand() {
     if (this.options.binaryPath !== undefined && this.options.binaryPath !== DEFAULT_BINARY) {
       return commandFor(this.options.binaryPath);
@@ -942,7 +940,7 @@ class JikjiClient {
   }
 }
 function spawnJikji(request) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve) => {
     const options = request.options;
     const portable = portableSpawnCommand(request.command, request.args);
     const child = spawn3(portable.command, [...portable.args], {
@@ -987,7 +985,7 @@ function spawnJikji(request) {
       settled = true;
       clearTimeout(timeout);
       request.signal?.removeEventListener("abort", abortHandler);
-      resolve7({ 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)
@@ -996,10 +994,10 @@ function spawnJikji(request) {
       clearTimeout(timeout);
       request.signal?.removeEventListener("abort", abortHandler);
       if (finalReason !== undefined) {
-        resolve7({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
+        resolve({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
         return;
       }
-      resolve7({ ok: code === 0, stdout: stdout.text, stderr: stderr.text, code });
+      resolve({ ok: code === 0, stdout: stdout.text, stderr: stderr.text, code });
     });
   });
 }
@@ -1141,7 +1139,7 @@ var init_jikji = __esm(() => {
 
 // src/manifest/loader.ts
 import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync3 } from "node:fs";
-import { extname as extname2, join as join5 } from "node:path";
+import { extname as extname2, join as join6 } from "node:path";
 import { parse as parseYaml } from "yaml";
 function isValidManifest(data) {
   if (typeof data !== "object" || data === null)
@@ -1187,7 +1185,7 @@ function loadManifests(dirPath) {
     const ext = extname2(entry).toLowerCase();
     if (ext !== ".yaml" && ext !== ".yml" && ext !== ".json")
       continue;
-    const filePath = join5(dirPath, entry);
+    const filePath = join6(dirPath, entry);
     try {
       const manifest = loadManifest(filePath);
       manifests.push(manifest);
@@ -1316,7 +1314,7 @@ import {
   unlinkSync,
   writeSync
 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function hasErrorCode(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
@@ -1465,7 +1463,7 @@ function reapStaleLockDirectory(lockPath, staleMs) {
     return removeEmptyLockDirectory(lockPath);
   const staleSnapshots = [];
   for (const name of names) {
-    const inspection = inspectRegularFile(join6(lockPath, name));
+    const inspection = inspectRegularFile(join7(lockPath, name));
     if (inspection.kind === "missing")
       continue;
     if (inspection.kind !== "file" || !isStaleSnapshot(inspection, staleMs))
@@ -1527,7 +1525,7 @@ function tryCreateOwnerMarker(lockPath, owner, contents) {
     throw error;
   }
   const markerName = `owner-${owner.token}.json`;
-  const markerPath = join6(lockPath, markerName);
+  const markerPath = join7(lockPath, markerName);
   let acquired = false;
   try {
     try {
@@ -1981,11 +1979,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: randomUUID3(),
-          target: { type: "evidence_chunk", stableEvidenceId: stableEvidenceId2 },
+          target: { type: "evidence_chunk", stableEvidenceId },
           query: curated.query,
           method: evidence?.method,
           sentiment,
@@ -2071,8 +2069,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);
@@ -2434,10 +2432,10 @@ var init_memory = __esm(() => {
 
 // src/minsync/embedder-config.ts
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 import { parse, stringify } from "smol-toml";
 function minSyncConfigPath(workspacePath) {
-  return join7(workspacePath, MINSYNC_CONFIG_DIR, MINSYNC_CONFIG_FILE);
+  return join8(workspacePath, MINSYNC_CONFIG_DIR, MINSYNC_CONFIG_FILE);
 }
 function configuredMaxChunkSize(workspacePath) {
   let raw;
@@ -2505,7 +2503,7 @@ var init_embedder_config = () => {};
 // src/minsync/process.ts
 import { spawn as spawn4 } from "node:child_process";
 function spawnProcess(command, args, cwd, options = {}) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve) => {
     const portable = portableSpawnCommand(command, args);
     const child = spawn4(portable.command, [...portable.args], { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
@@ -2526,15 +2524,15 @@ function spawnProcess(command, args, cwd, options = {}) {
     child.on("error", (error) => {
       if (timer)
         clearTimeout(timer);
-      resolve8({ 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) {
-        resolve8({ ok: false, stdout, stderr: "process timed out", code: null, timedOut: true });
+        resolve({ ok: false, stdout, stderr: "process timed out", code: null, timedOut: true });
       } else {
-        resolve8({ ok: code === 0, stdout, stderr, code });
+        resolve({ ok: code === 0, stdout, stderr, code });
       }
     });
   });
@@ -2545,7 +2543,7 @@ var init_process = __esm(() => {
 
 // src/minsync/client.ts
 import { existsSync as existsSync7, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 
 class MinSyncClient {
   binaryPath;
@@ -2579,7 +2577,7 @@ class MinSyncClient {
     }
     const spawnOpts = this.embedder?.timeoutMs !== undefined ? { timeoutMs: this.embedder.timeoutMs } : {};
     const initialized = existsSync7(minSyncConfigPath(this.workspacePath));
-    const cursorPath = join8(this.workspacePath, ".minsync", "cursor.json");
+    const cursorPath = join9(this.workspacePath, ".minsync", "cursor.json");
     if (!initialized) {
       const initArgs = ["init", "--format", "json"];
       if (this.embedder?.id) {
@@ -2724,10 +2722,10 @@ import { copyFileSync, createWriteStream, existsSync as existsSync8, mkdirSync a
 import { chmod, mkdtemp } from "node:fs/promises";
 import { get } from "node:https";
 import { tmpdir } from "node:os";
-import { basename as basename2, dirname as dirname4, join as join9 } from "node:path";
+import { basename as basename2, dirname as dirname4, join as join10 } from "node:path";
 import { pipeline } from "node:stream/promises";
 async function ensureMinSyncBinary(options) {
-  const binaryPath = join9(options.root, ".autorag", "bin", executableName(options.platform ?? process.platform));
+  const binaryPath = join10(options.root, ".autorag", "bin", executableName(options.platform ?? process.platform));
   if (existsSync8(binaryPath))
     return { binaryPath, version: "cached" };
   const releaseProvider = options.releaseProvider ?? fetchLatestMinSyncRelease;
@@ -2748,14 +2746,14 @@ async function ensureMinSyncBinary(options) {
   return { binaryPath, version: release.tagName };
 }
 async function installMinSyncFromCargo(options, destination) {
-  const cargoRoot = join9(options.root, ".autorag", "minsync-cargo");
+  const cargoRoot = join10(options.root, ".autorag", "minsync-cargo");
   mkdirSync4(dirname4(destination), { recursive: true });
   mkdirSync4(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`);
   }
-  const installedBinary = join9(cargoRoot, "bin", executableName(options.platform ?? process.platform));
+  const installedBinary = join10(cargoRoot, "bin", executableName(options.platform ?? process.platform));
   if (!existsSync8(installedBinary)) {
     throw new MinSyncReleaseError(`Cargo did not produce the MinSync ${MINSYNC_VERSION} binary`);
   }
@@ -2786,9 +2784,9 @@ function selectReleaseAsset(release, platform, arch) {
 }
 async function installReleaseAsset(asset, destination) {
   const expectedSha256 = requireSha256(asset);
-  const tempDir = await mkdtemp(join9(tmpdir(), "autorag-minsync-install-"));
+  const tempDir = await mkdtemp(join10(tmpdir(), "autorag-minsync-install-"));
   try {
-    const archive = join9(tempDir, asset.name);
+    const archive = join10(tempDir, asset.name);
     await downloadFile(asset.downloadUrl, archive);
     await verifySha256(archive, expectedSha256);
     if (!asset.name.endsWith(".tar.gz") && !asset.name.endsWith(".zip")) {
@@ -2797,7 +2795,7 @@ async function installReleaseAsset(asset, destination) {
     const extracted = await spawnProcess("tar", ["-xf", archive, "-C", tempDir], tempDir);
     if (!extracted.ok)
       throw new MinSyncReleaseError(extracted.stderr || `Could not extract ${asset.name}`);
-    renameSync3(join9(tempDir, basename2(destination)), destination);
+    renameSync3(join10(tempDir, basename2(destination)), destination);
   } finally {
     rmSync2(tempDir, { recursive: true, force: true });
   }
@@ -2814,11 +2812,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((resolve8, 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(resolve8, reject);
+        readHttpsText(new URL(response.headers.location, url).toString(), redirectCount + 1).then(resolve, reject);
         return;
       }
       if (redirectCount > 5) {
@@ -2837,17 +2835,17 @@ function readHttpsText(url, redirectCount = 0) {
         body += chunk;
       });
       response.on("end", () => {
-        resolve8(body);
+        resolve(body);
       });
     }).on("error", reject);
   });
 }
 function openHttps(url, redirectCount = 0) {
-  return new Promise((resolve8, 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(resolve8, reject);
+        openHttps(new URL(response.headers.location, url).toString(), redirectCount + 1).then(resolve, reject);
         return;
       }
       if (redirectCount > 5) {
@@ -2860,7 +2858,7 @@ function openHttps(url, redirectCount = 0) {
         response.resume();
         return;
       }
-      resolve8(response);
+      resolve(response);
     }).on("error", reject);
   });
 }
@@ -2907,28 +2905,6 @@ var init_installer2 = __esm(() => {
   };
 });
 
-// src/retrieval/methods/bm25.ts
-import { existsSync as existsSync9, rmSync as rmSync3 } from "node:fs";
-import { join as join10 } from "node:path";
-function removeLegacyBm25Artifacts(root) {
-  rmSync3(join10(root, BM25_SUBDIR), { recursive: true, force: true });
-}
-function hasLegacyBm25Artifacts(root) {
-  return existsSync9(join10(root, BM25_SUBDIR));
-}
-var BM25_SUBDIR, BM25UnavailableError;
-var init_bm25 = __esm(() => {
-  BM25_SUBDIR = join10(".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 join11 } from "node:path";
 function minSyncWorkspaceRoot(root) {
@@ -2947,13 +2923,13 @@ var init_paths2 = __esm(() => {
 import { randomUUID as randomUUID4 } from "node:crypto";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync10,
+  existsSync as existsSync9,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync3,
   readFileSync as readFileSync8,
   renameSync as renameSync4,
-  rmSync as rmSync4,
+  rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute5, join as join12, relative as relative4, sep as sep3 } from "node:path";
@@ -2961,7 +2937,7 @@ function syncMinSyncWorkspace(root, options = {}) {
   const workspacePath = options.workspacePath ?? minSyncWorkspaceRoot(root);
   const filesRoot = join12(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 && existsSync10(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 && existsSync9(entry.outputPath)).map((entry) => {
     const minSyncPath = minSyncDocumentPath(workspacePath, entry.virtualPath);
     return {
       virtualPath: entry.virtualPath,
@@ -3023,7 +2999,7 @@ function isMinSyncStagingState(value) {
 function ensureManagedFilesRoot(filesRoot, rebuild) {
   const status = lstatSync2(filesRoot, { throwIfNoEntry: false });
   if (status !== undefined && (rebuild || !status.isDirectory())) {
-    rmSync4(filesRoot, { recursive: status.isDirectory(), force: true });
+    rmSync3(filesRoot, { recursive: status.isDirectory(), force: true });
   }
   mkdirSync5(filesRoot, { recursive: true });
 }
@@ -3040,7 +3016,7 @@ function ensureManagedDirectory(filesRoot, directory) {
     if (status?.isDirectory())
       continue;
     if (status !== undefined) {
-      rmSync4(current, { force: true });
+      rmSync3(current, { force: true });
     }
     mkdirSync5(current);
   }
@@ -3051,7 +3027,7 @@ function copyFileAtomically(source, destination) {
     copyFileSync2(source, temporaryPath);
     renameSync4(temporaryPath, destination);
   } finally {
-    rmSync4(temporaryPath, { force: true });
+    rmSync3(temporaryPath, { force: true });
   }
 }
 function isRegularFile(path) {
@@ -3063,7 +3039,7 @@ function removeUnexpectedStagedFiles(directory, desiredPaths) {
     if (entry.isDirectory()) {
       removeUnexpectedStagedFiles(path, desiredPaths);
     } else if (!desiredPaths.has(path)) {
-      rmSync4(path, { force: true });
+      rmSync3(path, { force: true });
     }
   }
 }
@@ -3098,7 +3074,7 @@ var init_workspace = __esm(() => {
 });
 
 // src/minsync/method.ts
-import { accessSync, constants, existsSync as existsSync11, realpathSync as realpathSync3 } from "node:fs";
+import { accessSync, constants, existsSync as existsSync10, realpathSync as realpathSync3 } from "node:fs";
 import { basename as basename4, delimiter as delimiter2, join as join13, normalize } from "node:path";
 function degrade(workspacePath, reason) {
   return { ok: false, synced: 0, workspacePath, reason };
@@ -3171,7 +3147,10 @@ class MinSyncVectorMethod {
     return binaryResult;
   }
   isBinaryMissing() {
-    return this.binaryPath !== undefined && !existsSync11(this.binaryPath);
+    return this.binaryPath !== undefined && !existsSync10(this.binaryPath);
+  }
+  isReady() {
+    return existsSync10(join13(this.workspacePath, ".minsync", "cursor.json"));
   }
   async retrieve(query, options) {
     const topK = options.topK ?? 20;
@@ -3211,16 +3190,15 @@ class MinSyncVectorMethod {
     return results;
   }
   async resolveBinary() {
-    if (this.binaryPath && existsSync11(this.binaryPath)) {
+    if (this.binaryPath && existsSync10(this.binaryPath))
       return this.binaryPath;
-    }
     if (this.binaryPath !== undefined)
       return;
     const pathBinary = lookupInPath(process.env);
     if (pathBinary)
       return pathBinary;
     const cachedBinary = join13(this.root, ".autorag", "bin", executableName(process.platform));
-    if (existsSync11(cachedBinary))
+    if (existsSync10(cachedBinary))
       return cachedBinary;
     if (this.autoInstall) {
       try {
@@ -3233,63 +3211,13 @@ class MinSyncVectorMethod {
     return;
   }
 }
-var MinSyncBM25Method, MinSyncHybridMethod;
+var MinSyncHybridMethod;
 var init_method = __esm(() => {
-  init_bm25();
   init_scope();
   init_client2();
   init_installer2();
   init_paths2();
   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" });
@@ -3473,7 +3401,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(" | ")} |`,
@@ -3934,7 +3862,7 @@ async function readZipXmlText(bytes, pathPattern) {
 }
 async function readXmlFile(file, remainingBytes) {
   const stream = file.nodeStream("nodebuffer");
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve, reject) => {
     const chunks = [];
     let totalBytes = 0;
     stream.on("data", (chunk) => {
@@ -3948,7 +3876,7 @@ async function readXmlFile(file, remainingBytes) {
       chunks.push(buffer);
     });
     stream.on("error", reject);
-    stream.on("end", () => resolve8(Buffer2.concat(chunks).toString("utf8")));
+    stream.on("end", () => resolve(Buffer2.concat(chunks).toString("utf8")));
   });
 }
 function uncompressedSize(file) {
@@ -4054,8 +3982,8 @@ function tesseractOcr(input) {
   let cleanupReject = () => {
     return;
   };
-  const cleanup = new Promise((resolve8, reject) => {
-    cleanupResolve = resolve8;
+  const cleanup = new Promise((resolve, reject) => {
+    cleanupResolve = resolve;
     cleanupReject = reject;
   });
   const result = runTesseractOcr(input, cleanupResolve, cleanupReject);
@@ -4064,7 +3992,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(() => {
@@ -4074,7 +4002,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 });
@@ -4086,18 +4014,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((resolve8, 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);
-      resolve8(value);
+      resolve(value);
     }, (error) => {
       clearTimeout(timeout);
       operation.cleanup.then(() => reject(error), (cleanupError) => reject(cleanupError));
@@ -4380,17 +4308,17 @@ import { extname as extname5 } 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) {
@@ -4433,14 +4361,14 @@ var init_defaults = __esm(() => {
 
 // src/mirror/sync.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, renameSync as renameSync5, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, renameSync as renameSync5, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
 import { opendir, readFile as readFile3, stat as stat2 } from "node:fs/promises";
 import { dirname as dirname6, extname as extname6, resolve as resolve8 } from "node:path";
-function parserFailureCode(parser2, error) {
-  return parser2.name === "opendataloader-pdf" && /UnsupportedClassVersionError/.test(error.message) ? "pdf-java-version" : "parser-failed";
+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.";
@@ -4480,8 +4408,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;
@@ -4504,12 +4432,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 && existsSync12(outputPath);
+    const unchanged = !options.force && previousEntry?.sourceMtimeNs === entry.mtimeNs && previousEntry.sourceSizeBytes === entry.sizeBytes && previousEntry.parserName === parser.name && existsSync11(outputPath);
     if (!unchanged) {
       let parsed;
       try {
         const bytes = await readFile3(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;
@@ -4517,9 +4445,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;
@@ -4543,7 +4471,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()
@@ -4602,8 +4530,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));
     }
   }
@@ -4669,8 +4597,8 @@ function writeAtomic(path, content) {
   renameSync5(tmp, path);
 }
 function removeFile(path) {
-  if (existsSync12(path))
-    rmSync5(path, { force: true });
+  if (existsSync11(path))
+    rmSync4(path, { force: true });
 }
 var DEFAULT_MAX_SOURCE_BYTES, MIRROR_CHECKPOINT_EVERY = 25, SKIP_DIR_NAMES;
 var init_sync = __esm(() => {
@@ -4838,8 +4766,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;
@@ -4994,9 +4920,9 @@ var init_cloud_placeholder = __esm(() => {
 import { spawn as spawn5 } from "node:child_process";
 import { Type as Type2 } from "typebox";
 function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve) => {
     if (signal?.aborted) {
-      resolve9({
+      resolve({
         output: "",
         exitCode: undefined,
         aborted: true,
@@ -5053,7 +4979,7 @@ function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
       if (killGraceTimer !== undefined)
         clearTimeout(killGraceTimer);
       signal?.removeEventListener("abort", onAbort);
-      resolve9({
+      resolve({
         output: Buffer.concat(chunks).toString("utf8"),
         exitCode,
         aborted,
@@ -5073,7 +4999,7 @@ function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
       if (child.pid === undefined)
         return true;
       if (process.platform === "win32") {
-        return await new Promise((resolve10) => {
+        return await new Promise((resolve) => {
           const killer = spawn5("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
           let completed = false;
           const graceTimer = setTimeout(() => {
@@ -5081,7 +5007,7 @@ function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
               return;
             completed = true;
             killer.kill();
-            resolve10(killDirectChild());
+            resolve(killDirectChild());
           }, KILL_EXIT_GRACE_MS);
           const finishKill = (success) => {
             if (completed)
@@ -5090,7 +5016,7 @@ function runCommand(command, cwd, timeoutMs, maxOutputBytes, signal) {
             clearTimeout(graceTimer);
             if (!success)
               killDirectChild();
-            resolve10(success);
+            resolve(success);
           };
           killer.on("error", () => finishKill(false));
           killer.on("close", (code) => finishKill(code === 0));
@@ -5616,7 +5542,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();
@@ -5669,92 +5595,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,
@@ -5774,7 +5616,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,
@@ -5785,7 +5627,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(", ")}` : "";
@@ -5804,10 +5646,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/**." }))
   });
 });
 
@@ -5947,7 +5789,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,
@@ -5957,10 +5799,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 {
@@ -5975,7 +5817,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,
@@ -5984,12 +5826,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: {
@@ -6000,7 +5842,7 @@ function unavailableResult2(message) {
     }
   };
 }
-function formatResults4(results) {
+function formatResults3(results) {
   if (results.length === 0)
     return "No MinSync results.";
   const rows = results.map((result, index) => {
@@ -6016,12 +5858,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/**." }))
   });
 });
 
@@ -6038,7 +5880,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"),
@@ -6049,7 +5890,6 @@ function buildSystemPrompt(config) {
       "bash",
       "jikji_find",
       "search_all_documents",
-      "lexical_search_local_docs",
       "semantic_search_local_docs",
       "search_datasource_documents",
       "load_datasource_skill",
@@ -6082,8 +5922,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.
@@ -6096,14 +5936,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
@@ -6228,6 +6071,10 @@ class AutoRAGAgent {
   resultCapture;
   autoRefreshTimer;
   refreshing = false;
+  jikjiPrepareInFlight;
+  jikjiReady = false;
+  minSyncPrepareInFlight;
+  minSyncReady = false;
   refreshState = {
     inFlight: false,
     lastOutcome: "never",
@@ -6247,7 +6094,6 @@ class AutoRAGAgent {
   merger = new ResultMerger;
   datasourceFilter = new DatasourceResultFilter;
   minSyncMethod;
-  bm25Method;
   jikjiClient;
   datasourceSkills;
   datasourceAccessOptions;
@@ -6261,6 +6107,7 @@ class AutoRAGAgent {
   searchTimeoutMs;
   maxSearchToolCalls;
   searchToolCallCount = 0;
+  sourceSearchCallCounts = new Map;
   constructor(options) {
     const { manifestDir, memoryPath } = options;
     this.configuredModel = options.model;
@@ -6293,16 +6140,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())
@@ -6313,13 +6153,13 @@ class AutoRAGAgent {
         ...options.jikji ?? {},
         root: this.workspaceProjectRoot
       });
+      this.jikjiReady = this.searchPaths.every((searchPath) => this.jikjiClient?.isPrepared(searchPath) === true);
     }
     const memPath = memoryPath ?? join16(resolveAutoRAGHome(), "memory.json");
     this.memory = new RetrievalMemory({ storagePath: memPath });
     this.memory.load();
     this.runLogger = new AutoRAGRunLogger(join16(dirname9(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);
@@ -6333,7 +6173,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,
@@ -6355,7 +6194,6 @@ class AutoRAGAgent {
       bashTool,
       ...callerTools,
       checkMemoryTool,
-      searchBM25Tool,
       searchMinSyncTool,
       searchAllTool,
       searchDatasourceTool,
@@ -6370,7 +6208,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 = {
@@ -6479,6 +6317,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;
@@ -6577,8 +6436,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 = [];
@@ -6603,8 +6465,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(() => {
@@ -6663,6 +6531,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,
@@ -6721,17 +6656,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",
@@ -6746,51 +6670,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,
@@ -6798,13 +6755,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 = {
@@ -6828,9 +6781,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
       };
@@ -6900,11 +6852,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";
@@ -6991,13 +6940,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();
@@ -7010,8 +6957,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 {
@@ -7031,6 +6990,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,
@@ -7305,7 +7281,6 @@ var init_agent = __esm(() => {
   init_paths();
   init_sync();
   init_run_log();
-  init_bm25();
   init_scope();
   init_bash_tool();
   init_datasource_skill();
@@ -7314,7 +7289,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();
@@ -7324,7 +7298,6 @@ 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
   ];
@@ -7486,7 +7459,7 @@ function sanitizeIdSegment(value) {
 var init_connector = () => {};
 
 // src/datasource/chunk-store.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname10, join as join17 } from "node:path";
 function datasourceChunkStorePath(workspaceRoot, skillName, instanceId) {
   return join17(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId), "chunks.json");
@@ -7526,7 +7499,7 @@ class DatasourceChunkStore {
     if (this.storePath === undefined)
       return false;
     try {
-      if (!existsSync13(this.storePath))
+      if (!existsSync12(this.storePath))
         return false;
       const parsed = JSON.parse(readFileSync10(this.storePath, "utf8"));
       if (parsed.version !== STORE_VERSION || !Array.isArray(parsed.chunks))
@@ -8082,7 +8055,7 @@ var DEFAULT_TIMEOUT_MS3 = 15000;
 
 // src/datasource/skills/cloud-drive/rclone-connector.ts
 import { spawn as spawn6 } from "node:child_process";
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync11, renameSync as renameSync6, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync11, renameSync as renameSync6, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
 import { dirname as dirname11, join as join18, normalize as normalize2 } from "node:path";
 
@@ -8177,12 +8150,12 @@ class RcloneConnector {
         copied = await this.runner(copyArgs(remote, entry.path, temp, exportFormats, this.options.concurrency, this.options.bandwidthLimit), timeoutMs);
       } catch {
         copyFailure = { reason: "unavailable", message: "rclone copy failed unexpectedly" };
-        rmSync6(temp, { force: true });
+        rmSync5(temp, { force: true });
         return;
       }
       if (!copied.ok) {
         copyFailure = { reason: classifyFailure(copied.stderr), message: shortFailure(copied) };
-        rmSync6(temp, { force: true });
+        rmSync5(temp, { force: true });
         return;
       }
       staged.push({ temp, destination });
@@ -8192,13 +8165,13 @@ class RcloneConnector {
     await Promise.all(Array.from({ length: concurrency }, () => copyOne()));
     if (copyFailure !== undefined) {
       for (const file of staged)
-        rmSync6(file.temp, { force: true });
+        rmSync5(file.temp, { force: true });
       return { ok: false, reason: copyFailure.reason, message: copyFailure.message };
     }
     for (const file of staged)
       renameSync6(file.temp, file.destination);
     for (const entry of deletedEntries)
-      rmSync6(mirrorFilePath(paths.mirrorRoot, entry.path), { force: true });
+      rmSync5(mirrorFilePath(paths.mirrorRoot, entry.path), { force: true });
     saveManifest(paths.manifestPath, { version: 1, remoteName: remoteName(remote), entries: inventory });
     const mirrorWarnings = await loadMirroredDocuments(paths.mirrorRoot, changedEntries, skillName, instanceId, remote, this.options.parserOptions);
     const warnings = [
@@ -8321,11 +8294,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 readFile4(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}`);
       }
@@ -8342,8 +8315,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()}`);
     }
   }
@@ -8575,7 +8548,7 @@ function commonArgs(options) {
   return options.configPath === undefined ? [] : ["--config", options.configPath];
 }
 function spawnDiscrawl(request) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve) => {
     const { options, args, env, signal } = request;
     const portable = portableSpawnCommand(options.binaryPath ?? DEFAULT_DISCRAWL_BINARY, args);
     const child = spawn7(portable.command, [...portable.args], {
@@ -8623,7 +8596,7 @@ function spawnDiscrawl(request) {
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
       const reason = error.code === "ENOENT" ? "binary-missing" : "spawn-error";
-      resolve10({ 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)
@@ -8632,10 +8605,10 @@ function spawnDiscrawl(request) {
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
       if (finalReason !== undefined) {
-        resolve10({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
+        resolve({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
         return;
       }
-      resolve10({
+      resolve({
         ok: code === 0,
         reason: code === 0 ? undefined : "nonzero-exit",
         stdout: stdout.text,
@@ -9332,7 +9305,7 @@ ${this.description}`
 
 // src/datasource/skills/clawgallery/client.ts
 import { spawn as spawn8 } from "node:child_process";
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 
 class ClawGalleryClient {
   options;
@@ -9340,7 +9313,7 @@ class ClawGalleryClient {
     this.options = options;
   }
   async bootstrap(signal) {
-    if (this.options.path !== undefined && !existsSync14(this.options.path)) {
+    if (this.options.path !== undefined && !existsSync13(this.options.path)) {
       return {
         ok: false,
         reason: "nonzero-exit",
@@ -9434,7 +9407,7 @@ class ClawGalleryClient {
   }
 }
 function spawnCli(binary, args, env, options, signal) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve) => {
     const portable = portableSpawnCommand(binary, args);
     const child = spawn8(portable.command, [...portable.args], { env, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
@@ -9475,7 +9448,7 @@ function spawnCli(binary, args, env, options, signal) {
       settled = true;
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abort);
-      resolve10({
+      resolve({
         ok: false,
         stdout,
         stderr: error.code === "ENOENT" ? "clawgallery binary not found" : "clawgallery could not start",
@@ -9489,7 +9462,7 @@ function spawnCli(binary, args, env, options, signal) {
       settled = true;
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abort);
-      resolve10({
+      resolve({
         ok: reason === undefined && code === 0,
         stdout,
         stderr: stderr.slice(0, max),
@@ -9923,228 +9896,6 @@ var init_github = __esm(() => {
   init_skill4();
 });
 
-// src/datasource/skills/gmail/himalaya-connector.ts
-import { spawn as spawn9 } from "node:child_process";
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname12, join as join19 } from "node:path";
-
-class HimalayaConnector {
-  options;
-  runner;
-  constructor(options = {}) {
-    this.options = options;
-    this.runner = options.runner ?? ((args, timeoutMs) => runBinary2(options.binaryPath ?? DEFAULT_BINARY4, args, timeoutMs, {
-      ...options.configPath === undefined ? {} : { HIMALAYA_CONFIG: options.configPath }
-    }));
-  }
-  async fetch() {
-    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
-    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(readFileSync12(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 {
-      mkdirSync10(dirname12(path), { recursive: true });
-      writeFileSync9(path, `${JSON.stringify(state)}
-`, "utf8");
-    } catch {}
-  }
-  statePath() {
-    if (this.options.workspaceRoot === undefined)
-      return;
-    return join19(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 = spawn9(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_BINARY4 = "himalaya", DEFAULT_PAGE_SIZE = 100, DEFAULT_MAX_DOCUMENTS3 = 50, DEFAULT_TIMEOUT_MS6 = 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;
@@ -10163,7 +9914,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) {
@@ -10211,7 +9962,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;
@@ -10277,7 +10028,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
@@ -10289,14 +10040,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 = {}) {
@@ -10312,7 +10060,6 @@ var init_skill5 = __esm(() => {
 // src/datasource/skills/gmail/index.ts
 var init_gmail = __esm(() => {
   init_connector3();
-  init_himalaya_connector();
   init_skill5();
 });
 
@@ -10321,7 +10068,7 @@ var DEFAULT_KATOK_BINARY = "katok", DEFAULT_KATOK_TIMEOUT_MS = 60000, DEFAULT_KA
 var init_types3 = () => {};
 
 // src/datasource/skills/katok/client.ts
-import { spawn as spawn10 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 
 class KatokClient {
   options;
@@ -10423,10 +10170,10 @@ class KatokClient {
   }
 }
 function spawnKatok(request) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve) => {
     const { options, args, env, signal } = request;
     const portable = portableSpawnCommand(commandFor2(options.binaryPath), args);
-    const child = spawn10(portable.command, [...portable.args], {
+    const child = spawn9(portable.command, [...portable.args], {
       env,
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -10470,7 +10217,7 @@ function spawnKatok(request) {
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
       const reason = error.code === "ENOENT" ? "binary-missing" : "spawn-error";
-      resolve10({ 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)
@@ -10479,10 +10226,10 @@ function spawnKatok(request) {
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
       if (finalReason !== undefined) {
-        resolve10({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
+        resolve({ ok: false, reason: finalReason, stdout: stdout.text, stderr: stderr.text, code });
         return;
       }
-      resolve10({
+      resolve({
         ok: code === 0,
         reason: code === 0 ? undefined : "nonzero-exit",
         stdout: stdout.text,
@@ -10981,7 +10728,7 @@ var init_katok = __esm(() => {
 
 // src/datasource/skills/mail-export/connector.ts
 import { readdir, readFile as readFile5, stat as stat3 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname13, extname as extname7, join as join20 } from "node:path";
+import { basename as basename6, dirname as dirname12, extname as extname7, join as join19 } from "node:path";
 import { simpleParser as simpleParser2 } from "mailparser";
 
 class MailExportConnector {
@@ -10993,7 +10740,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;
@@ -11007,7 +10754,7 @@ class MailExportConnector {
               continue;
             const extension = extname7(entry.name).toLowerCase();
             if (extension === ".eml" || extension === ".mbox") {
-              files.push(join20(entry.parentPath, entry.name));
+              files.push(join19(entry.parentPath, entry.name));
             }
           }
         } else if (info.isFile()) {
@@ -11042,7 +10789,7 @@ class MailExportConnector {
         continue;
       }
       const stem = basename6(file, extname7(file));
-      const mailboxDir = basename6(dirname13(file));
+      const mailboxDir = basename6(dirname12(file));
       const hierarchy = ["mailboxes", mailboxDir, stem];
       const extension = extname7(file).toLowerCase();
       const rawMessages = extension === ".mbox" ? splitMbox(bytes.toString("utf8")) : [bytes.toString("utf8")];
@@ -11054,7 +10801,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}`] : [],
@@ -11111,7 +10858,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;
@@ -11152,21 +10899,21 @@ var init_mail_export = __esm(() => {
 });
 
 // src/datasource/skills/mailcrawl/config.ts
-import { chmodSync, mkdirSync as mkdirSync11 } from "node:fs";
+import { chmodSync, mkdirSync as mkdirSync10 } 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) {
-  mkdirSync11(path, { recursive: true, mode: 448 });
+  mkdirSync10(path, { recursive: true, mode: 448 });
   if (process.platform !== "win32")
     chmodSync(path, 448);
 }
 var init_config = () => {};
 
 // src/datasource/skills/mailcrawl/client.ts
-import { spawn as spawn11 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 
 class MailcrawlClient {
   options;
@@ -11260,7 +11007,7 @@ class MailcrawlClient {
     }
     if (dataDir !== undefined)
       env.MAILCRAWL_DATA_DIR = dataDir;
-    return spawnMailcrawl(this.options.binaryPath ?? DEFAULT_BINARY5, args, env, this.options, signal);
+    return spawnMailcrawl(this.options.binaryPath ?? DEFAULT_BINARY4, args, env, this.options, signal);
   }
   async index(signal) {
     const result = await this.run(["index", "--json"], signal);
@@ -11280,7 +11027,7 @@ class MailcrawlClient {
 function spawnMailcrawl(binary, args, env, options, signal) {
   return new Promise((resolveResult) => {
     const portable = portableSpawnCommand(binary, args);
-    const child = spawn11(portable.command, portable.args, {
+    const child = spawn10(portable.command, portable.args, {
       env,
       detached: process.platform !== "win32",
       stdio: ["ignore", "pipe", "pipe"]
@@ -11290,7 +11037,7 @@ function spawnMailcrawl(binary, args, env, options, signal) {
     const timer = setTimeout(() => {
       reason = "timeout";
       terminate5(child);
-    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS7);
+    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS6);
     const abort = () => {
       reason = "aborted";
       terminate5(child);
@@ -11463,7 +11210,7 @@ function truncateUtf8(value, maxBytes) {
   }
   return "";
 }
-var DEFAULT_BINARY5 = "mailcrawl", DEFAULT_TIMEOUT_MS7 = 60000, DEFAULT_MAX_BUFFER_BYTES3 = 1048576, SAFE_ENV_KEYS, SAFE_MAILCRAWL_ENV_KEYS, REMOTE_EMBEDDING_ENV_KEYS;
+var DEFAULT_BINARY4 = "mailcrawl", DEFAULT_TIMEOUT_MS6 = 60000, DEFAULT_MAX_BUFFER_BYTES3 = 1048576, SAFE_ENV_KEYS, SAFE_MAILCRAWL_ENV_KEYS, REMOTE_EMBEDDING_ENV_KEYS;
 var init_client6 = __esm(() => {
   init_portable_spawn();
   init_config();
@@ -11710,7 +11457,7 @@ var init_mailcrawl = __esm(() => {
 });
 
 // src/datasource/crawler-client.ts
-import { spawn as spawn12 } from "node:child_process";
+import { spawn as spawn11 } from "node:child_process";
 
 class CrawlerCliClient {
   profile;
@@ -11745,9 +11492,9 @@ class CrawlerCliClient {
   }
 }
 function spawnCrawler(command, args, env, signal, options, cwd) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve) => {
     const portable = portableSpawnCommand(command, args);
-    const child = spawn12(portable.command, [...portable.args], {
+    const child = spawn11(portable.command, [...portable.args], {
       env,
       ...cwd === undefined ? {} : { cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -11760,7 +11507,7 @@ function spawnCrawler(command, args, env, signal, options, cwd) {
     const timeout = setTimeout(() => {
       finalReason = "timeout";
       terminate6(child);
-    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS8);
+    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS7);
     const abortHandler = () => {
       finalReason = "aborted";
       terminate6(child);
@@ -11790,7 +11537,7 @@ function spawnCrawler(command, args, env, signal, options, cwd) {
       settled = true;
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
-      resolve10({
+      resolve({
         ok: false,
         reason: error.code === "ENOENT" ? "binary-missing" : "spawn-error",
         stdout: stdout.text,
@@ -11804,7 +11551,7 @@ function spawnCrawler(command, args, env, signal, options, cwd) {
       settled = true;
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abortHandler);
-      resolve10({
+      resolve({
         ok: code === 0 && finalReason === undefined,
         ...finalReason !== undefined ? { reason: finalReason } : code === 0 ? {} : { reason: "nonzero-exit" },
         stdout: stdout.text,
@@ -11852,7 +11599,7 @@ function toFailure3(binaryName, result, reason) {
     code: result.code
   };
 }
-var DEFAULT_TIMEOUT_MS8 = 60000, DEFAULT_MAX_BUFFER_BYTES4 = 1048576, SAFE_ENV_KEYS2;
+var DEFAULT_TIMEOUT_MS7 = 60000, DEFAULT_MAX_BUFFER_BYTES4 = 1048576, SAFE_ENV_KEYS2;
 var init_crawler_client = __esm(() => {
   init_portable_spawn();
   SAFE_ENV_KEYS2 = new Set([
@@ -12205,15 +11952,15 @@ var init_notion = __esm(() => {
 });
 
 // src/datasource/skills/obsidian/paths.ts
-import { join as join21 } from "node:path";
+import { join as join20 } from "node:path";
 function obsidianDatasourceRoot(workspaceRoot, instanceId) {
-  return join21(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, OBSIDIAN_DATASOURCE_DIRNAME, instanceId);
+  return join20(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, OBSIDIAN_DATASOURCE_DIRNAME, instanceId);
 }
 function obsidianQmdConfigDir(workspaceRoot, instanceId) {
-  return join21(obsidianDatasourceRoot(workspaceRoot, instanceId), "config");
+  return join20(obsidianDatasourceRoot(workspaceRoot, instanceId), "config");
 }
 function obsidianQmdCacheDir(workspaceRoot, instanceId) {
-  return join21(obsidianDatasourceRoot(workspaceRoot, instanceId), "cache");
+  return join20(obsidianDatasourceRoot(workspaceRoot, instanceId), "cache");
 }
 function stripEdgeDashes(value) {
   let start = 0;
@@ -12235,8 +11982,8 @@ var init_paths4 = () => {};
 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 spawn13 } from "node:child_process";
-import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync10 } from "node:fs";
+import { spawn as spawn12 } from "node:child_process";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync9 } from "node:fs";
 import { isAbsolute as isAbsolute6, resolve as resolve10 } from "node:path";
 
 class QmdClient {
@@ -12256,10 +12003,10 @@ class QmdClient {
     const cacheDir = obsidianQmdCacheDir(workspaceRoot, instanceId);
     try {
       if (this.options.configPath === undefined) {
-        mkdirSync12(configDir, { recursive: true });
-        writeFileSync10(resolve10(configDir, "index.yml"), renderIndexYaml(collectionName, vaultPath), "utf8");
+        mkdirSync11(configDir, { recursive: true });
+        writeFileSync9(resolve10(configDir, "index.yml"), renderIndexYaml(collectionName, vaultPath), "utf8");
       }
-      mkdirSync12(cacheDir, { recursive: true });
+      mkdirSync11(cacheDir, { recursive: true });
     } catch (error) {
       return failure3("spawn-error", error instanceof Error ? error.message : "failed to write qmd config");
     }
@@ -12360,7 +12107,7 @@ function isAllowedEnvKey2(key) {
 function spawnQmd(request) {
   return new Promise((resolveResult) => {
     const portable = portableSpawnCommand(request.binaryPath ?? DEFAULT_QMD_BINARY, request.args);
-    const child = spawn13(portable.command, [...portable.args], {
+    const child = spawn12(portable.command, [...portable.args], {
       env: request.env,
       ...request.cwd === undefined ? {} : { cwd: request.cwd },
       stdio: ["ignore", "pipe", "pipe"]
@@ -12906,7 +12653,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 = [];
@@ -13039,7 +12786,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
@@ -13211,7 +12958,7 @@ var init_slack = __esm(() => {
 });
 
 // src/datasource/skills/spotlight/connector.ts
-import { spawn as spawn14 } from "node:child_process";
+import { spawn as spawn13 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { readFile as fsReadFile, stat as stat4 } from "node:fs/promises";
 import { basename as basename7, extname as extname8 } from "node:path";
@@ -13235,7 +12982,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_MS9;
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS8;
     const status = await this.run("mdutil", ["-s", "/"], timeoutMs);
     if (status.ok && /indexing disabled/iu.test(status.stdout)) {
       return {
@@ -13245,7 +12992,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;
@@ -13329,8 +13076,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_MS9 = 15000, MAX_CONTENT_CHARS3 = 1e5, MAX_BUFFER_BYTES, FDA_GUIDANCE = "grant Full Disk Access to the terminal or app running AutoRAG (System Settings -> Privacy & Security -> Full Disk Access), then restart it", spawnRunner = (command, args, timeoutMs) => new Promise((resolve11) => {
-  const child = spawn14(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
+var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS6 = 300, DEFAULT_MAX_BYTES_PER_FILE3, DEFAULT_TIMEOUT_MS8 = 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 = spawn13(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
   let stdout = "";
   let stderr = "";
   let settled = false;
@@ -13339,7 +13086,7 @@ var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS7 = 300, DEFAULT_M
       return;
     settled = true;
     clearTimeout(timer);
-    resolve11(result);
+    resolve(result);
   };
   const timer = setTimeout(() => {
     child.kill("SIGKILL");
@@ -13681,12 +13428,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 };
@@ -13697,7 +13451,6 @@ var init_factory = __esm(() => {
   init_cloud_drive();
   init_discrawl();
   init_github();
-  init_himalaya_connector();
   init_gmail();
   init_katok();
   init_mail_export();
@@ -13816,17 +13569,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,
@@ -14104,13 +13848,10 @@ init_opendataloader_pdf();
 init_plain_text();
 init_registry();
 // src/retrieval/index.ts
-init_bm25();
 init_scope();
 export {
   AliasedDatasourceSkill,
   AutoRAGAgent,
-  BM25UnavailableError,
-  BM25_SUBDIR,
   BUILTIN_DATASOURCE_SKILL_NAMES,
   CLOUD_DRIVE_SKILL_DEFINITION,
   CloudDriveSkill,
@@ -14160,7 +13901,6 @@ export {
   MailcrawlClient,
   MailcrawlMethod,
   MailcrawlSkill,
-  MinSyncBM25Method,
   MinSyncClient,
   MinSyncHybridMethod,
   MinSyncReleaseError,
@@ -14213,7 +13953,6 @@ export {
   ensureMinSyncBinary,
   executableName,
   fetchLatestMinSyncRelease,
-  hasLegacyBm25Artifacts,
   isDatasourceSource,
   isDue,
   jikjiExecutableName,
@@ -14241,7 +13980,6 @@ export {
   parsedMirrorRoot,
   parsedOutputPath,
   planJikjiSourceRoots,
-  removeLegacyBm25Artifacts,
   renderMemoryContext,
   resolveReturnedPath,
   rewriteEmbedderConfig,