@autorag/librarian 2.10.0 → 2.10.1

package/dist/index.js

@@ -61,6 +61,7 @@ function datasourceCodeToRetrieval(code) {
     case "datasource-auth-error":
     case "datasource-embedding-egress-rejected":
     case "datasource-index-failed":
+    case "datasource-index-partial":
     case "datasource-permission-denied":
     case "datasource-remote-embedding-rejected":
       return "retrieval-method-failed";
@@ -1112,19 +1113,6 @@ var init_manifest = __esm(() => {
       artifactSha256: "06507c7b42688469c4e7298b0a1e16deff06caf291cf0a5b278c308249c3e439",
       backend: "auto",
       protocolCapabilities
-    },
-    "embeddinggemma-300m": {
-      profileId: "embeddinggemma-300m",
-      provider: "google",
-      model: "embeddinggemma-300M-Q8_0.gguf",
-      dimension: 768,
-      queryPrefix: "task: search result | query: ",
-      passagePrefix: "title: none | text: ",
-      runtimeBuild: RUNTIME_BUILD,
-      modelRevision: "0f741b5a6585bd53aeb15cd1372c56f2a0f65e12",
-      artifactSha256: "b5ce9d77a3fc4b3b39ccb5643c36777911cc4eb46a66962eadfa3f5f60490d63",
-      backend: "auto",
-      protocolCapabilities
     }
   };
   runtimeAssets = {
@@ -1170,17 +1158,6 @@ var init_manifest = __esm(() => {
       unsuitableUse: "Chat or generation, remote embedding of corpus text, shipping weights in the npm package, any GGUF other than the pinned SHA-256.",
       upstreamCardUrl: "https://huggingface.co/Qwen/Qwen3-Embedding-0.6B",
       modelCard: "docs/model-cards/qwen3-embedding-0.6b.md"
-    },
-    embeddinggemma: {
-      url: "https://huggingface.co/ggml-org/embeddinggemma-300M-GGUF/resolve/0f741b5a6585bd53aeb15cd1372c56f2a0f65e12/embeddinggemma-300M-Q8_0.gguf",
-      revision: "0f741b5a6585bd53aeb15cd1372c56f2a0f65e12",
-      sha256: "b5ce9d77a3fc4b3b39ccb5643c36777911cc4eb46a66962eadfa3f5f60490d63",
-      license: "Gemma Terms of Use",
-      noticeReference: "Google EmbeddingGemma model card and Gemma Terms of Use",
-      intendedUse: "Local loopback embedding for AutoRAG MinSync and native-datasource semantic retrieval. Not a generative model.",
-      unsuitableUse: "Chat or generation, remote embedding of corpus text, shipping weights in the npm package, any GGUF other than the pinned SHA-256, uses restricted by the Gemma Prohibited Use Policy.",
-      upstreamCardUrl: "https://ai.google.dev/gemma/docs/embeddinggemma/model_card",
-      modelCard: "docs/model-cards/embeddinggemma-300m.md"
     }
   };
 });
@@ -1618,7 +1595,7 @@ var init_supervisor = __esm(() => {
 // src/embedding-runtime/index.ts
 import { basename as basename4 } from "node:path";
 function modelAsset(profile) {
-  return profile.profileId === "qwen3-embedding-0.6b" ? { id: profile.profileId, filename: basename4(profile.model), ...MODEL_ASSETS.qwen3 } : { id: profile.profileId, filename: basename4(profile.model), ...MODEL_ASSETS.embeddinggemma };
+  return { id: profile.profileId, filename: basename4(profile.model), ...MODEL_ASSETS.qwen3 };
 }
 function runtimeAsset(platform, backend) {
   const selected = platform ?? "darwin-arm64-metal";
@@ -5020,7 +4997,12 @@ var init_local_embedder = __esm(() => {
 // src/minsync/process.ts
 import { spawn as spawn7 } from "node:child_process";
 function spawnProcess(command, args, cwd, options = {}) {
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
+    const { signal } = options;
+    if (signal?.aborted) {
+      reject(abortError(signal));
+      return;
+    }
     const portable = portableSpawnCommand(command, args);
     const child = spawn7(portable.command, [...portable.args], { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
@@ -5038,15 +5020,26 @@ function spawnProcess(command, args, cwd, options = {}) {
       timedOut = true;
       child.kill("SIGTERM");
     }, options.timeoutMs) : undefined;
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const settle = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    };
     child.on("error", (error) => {
-      if (timer)
-        clearTimeout(timer);
-      resolve({ ok: false, stdout, stderr: error.message, code: null });
+      settle();
+      if (signal?.aborted)
+        reject(abortError(signal));
+      else
+        resolve({ ok: false, stdout, stderr: error.message, code: null });
     });
     child.on("close", (code) => {
-      if (timer)
-        clearTimeout(timer);
-      if (timedOut) {
+      settle();
+      if (signal?.aborted) {
+        reject(abortError(signal));
+      } else if (timedOut) {
         resolve({ ok: false, stdout, stderr: "process timed out", code: null, timedOut: true });
       } else {
         resolve({ ok: code === 0, stdout, stderr, code });
@@ -5054,6 +5047,9 @@ function spawnProcess(command, args, cwd, options = {}) {
     });
   });
 }
+function abortError(signal) {
+  return signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
+}
 var init_process = __esm(() => {
   init_portable_spawn();
 });
@@ -5286,10 +5282,12 @@ class MinSyncClient {
       } : {}
     };
   }
-  async query(text, topK, mode = "vector") {
+  async query(text, topK, mode = "vector", signal) {
     if (!existsSync11(this.binaryPath))
       throw minSyncBinaryMissingError();
-    const result = await this.spawn(["query", "--format", "json", "--mode", mode, "-k", String(topK), text]);
+    const result = await this.spawn(["query", "--format", "json", "--mode", mode, "-k", String(topK), text], {
+      ...signal === undefined ? {} : { signal }
+    });
     if (!result.ok)
       throw new MinSyncQueryError(result.code, result.stderr);
     return parseQueryHits(result.stdout);
@@ -5362,7 +5360,7 @@ function isIdentity(value) {
 function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
-var MINSYNC_OLLAMA_MIGRATION_MESSAGE = "This workspace uses the legacy 768-dimensional Ollama/TEI embedding path. Reindex explicitly, or pin an explicit profile config before using the new default runtime.", API_KEY_ENV_PATTERN, MinSyncQueryError;
+var MINSYNC_OLLAMA_MIGRATION_MESSAGE = "This workspace uses the legacy 768-dimensional Ollama/TEI embedding path. Reindex explicitly, or pin an explicit Ollama/TEI embedder config before using the new default runtime.", API_KEY_ENV_PATTERN, MinSyncQueryError;
 var init_client4 = __esm(() => {
   init_embedder_config();
   init_errors();
@@ -5606,7 +5604,7 @@ function isGitHubAsset(value) {
 function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
-var LATEST_RELEASE_URL = "https://api.github.com/repos/NomaDamas/MinSync/releases/latest", SHA256_HEX_PATTERN, MINSYNC_VERSION = "0.4.6", MINSYNC_CARGO_INSTALL_TIMEOUT_MS, CARGO_PROBE_TIMEOUT_MS = 5000, MinSyncReleaseError;
+var LATEST_RELEASE_URL = "https://api.github.com/repos/NomaDamas/MinSync/releases/latest", SHA256_HEX_PATTERN, MINSYNC_VERSION = "0.4.7", MINSYNC_CARGO_INSTALL_TIMEOUT_MS, CARGO_PROBE_TIMEOUT_MS = 5000, MinSyncReleaseError;
 var init_installer2 = __esm(() => {
   init_process();
   SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/;
@@ -5915,11 +5913,11 @@ class MinSyncVectorMethod {
     });
     let hits;
     try {
-      hits = await client.query(query, queryK, this.mode);
+      hits = await client.query(query, queryK, this.mode, options.signal);
     } catch (error) {
-      if (this.mode !== "hybrid")
+      if (this.mode !== "hybrid" || options.signal?.aborted)
         throw error;
-      hits = await client.query(query, queryK, "bm25");
+      hits = await client.query(query, queryK, "bm25", options.signal);
     }
     const results = [];
     for (const hit of hits) {
@@ -6242,10 +6240,16 @@ async function runTesseract(recognition, signal, cleanupResolve, cleanupReject)
   };
   signal.addEventListener("abort", abort, { once: true });
   try {
+    const tooSmall = ocrImageTooSmallMessage(recognition.bytes);
+    if (tooSmall !== undefined)
+      throw new Error(tooSmall);
     const { cachePath } = recognition;
     if (cachePath !== undefined)
       await mkdir3(cachePath, { recursive: true });
-    worker = await createWorker(recognition.language, undefined, cachePath === undefined ? {} : { cachePath });
+    worker = await createWorker(recognition.language, undefined, {
+      ...cachePath === undefined ? {} : { cachePath },
+      errorHandler: containTesseractWorkerError
+    });
     if (signal.aborted)
       throw new Error("OCR aborted before worker was ready");
     const result = await worker.recognize(Buffer.from(recognition.bytes));
@@ -6255,6 +6259,129 @@ async function runTesseract(recognition, signal, cleanupResolve, cleanupReject)
     await terminate().then(cleanupResolve, cleanupReject);
   }
 }
+function containTesseractWorkerError(_payload) {}
+function ocrImageTooSmallMessage(bytes) {
+  const size = readImagePixelSize(bytes);
+  if (size === undefined || size.width >= MIN_LEPTONICA_SIDE_PIXELS && size.height >= MIN_LEPTONICA_SIDE_PIXELS) {
+    return;
+  }
+  return `Image is too small to scale (${size.width}x${size.height} vs minimum of ${MIN_LEPTONICA_SIDE_PIXELS} pixels).`;
+}
+function readImagePixelSize(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80)
+    return readPngSize(bytes);
+  if (bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 216)
+    return readJpegSize(bytes);
+  if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73)
+    return readWebpSize(bytes);
+  return;
+}
+function readPngSize(bytes) {
+  if (bytes.length < 24)
+    return;
+  if (bytes[0] !== 137 || bytes[1] !== 80 || bytes[2] !== 78 || bytes[3] !== 71 || bytes[4] !== 13 || bytes[5] !== 10 || bytes[6] !== 26 || bytes[7] !== 10) {
+    return;
+  }
+  if (bytes[12] !== 73 || bytes[13] !== 72 || bytes[14] !== 68 || bytes[15] !== 82)
+    return;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+function readJpegSize(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216)
+    return;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 2;
+  while (offset + 1 < bytes.length) {
+    if (bytes[offset] !== 255)
+      return;
+    offset += 1;
+    while (offset < bytes.length && bytes[offset] === 255)
+      offset += 1;
+    if (offset >= bytes.length)
+      return;
+    const marker = bytes[offset] ?? 0;
+    offset += 1;
+    if (marker === 0)
+      return;
+    if (marker === 1 || marker === 217 || marker >= 208 && marker <= 216)
+      continue;
+    if (offset + 2 > bytes.length)
+      return;
+    const segmentLength = view.getUint16(offset);
+    if (segmentLength < 2)
+      return;
+    if (isJpegStartOfFrame(marker)) {
+      if (segmentLength < 7 || offset + 7 > bytes.length)
+        return;
+      return { width: view.getUint16(offset + 5), height: view.getUint16(offset + 3) };
+    }
+    if (marker === 218)
+      return;
+    const next = offset + segmentLength;
+    if (next <= offset || next > bytes.length)
+      return;
+    offset = next;
+  }
+  return;
+}
+function isJpegStartOfFrame(marker) {
+  return marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204;
+}
+function readWebpSize(bytes) {
+  if (bytes.length < 20 || !asciiAt(bytes, 0, "RIFF") || !asciiAt(bytes, 8, "WEBP"))
+    return;
+  const chunkSize = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(16, true);
+  if (asciiAt(bytes, 12, "VP8X"))
+    return readVp8xSize(bytes, chunkSize);
+  if (asciiAt(bytes, 12, "VP8L"))
+    return readVp8lSize(bytes, chunkSize);
+  if (asciiAt(bytes, 12, "VP8 "))
+    return readVp8Size(bytes, chunkSize);
+  return;
+}
+function readVp8xSize(bytes, chunkSize) {
+  if (!webpPayloadFits(bytes, chunkSize, 10))
+    return;
+  const payload = 20;
+  const width = 1 + readU24LE(bytes, payload + 4);
+  const height = 1 + readU24LE(bytes, payload + 7);
+  return { width, height };
+}
+function readVp8lSize(bytes, chunkSize) {
+  if (!webpPayloadFits(bytes, chunkSize, 5) || bytes[20] !== 47)
+    return;
+  const b1 = bytes[21] ?? 0;
+  const b2 = bytes[22] ?? 0;
+  const b3 = bytes[23] ?? 0;
+  const b4 = bytes[24] ?? 0;
+  const width = 1 + (b1 | (b2 & 63) << 8);
+  const height = 1 + (b2 >> 6 | b3 << 2 | (b4 & 15) << 10);
+  return { width, height };
+}
+function readVp8Size(bytes, chunkSize) {
+  if (!webpPayloadFits(bytes, chunkSize, 10) || (bytes[20] & 1) !== 0)
+    return;
+  if (bytes[23] !== 157 || bytes[24] !== 1 || bytes[25] !== 42)
+    return;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return { width: view.getUint16(26, true) & 16383, height: view.getUint16(28, true) & 16383 };
+}
+function webpPayloadFits(bytes, chunkSize, needed) {
+  return chunkSize >= needed && bytes.length >= 20 + needed;
+}
+function readU24LE(bytes, offset) {
+  return (bytes[offset] ?? 0) | (bytes[offset + 1] ?? 0) << 8 | (bytes[offset + 2] ?? 0) << 16;
+}
+function asciiAt(bytes, offset, text) {
+  if (offset + text.length > bytes.length)
+    return false;
+  for (let index = 0;index < text.length; index += 1) {
+    if (bytes[offset + index] !== text.charCodeAt(index))
+      return false;
+  }
+  return true;
+}
 function withTimeout(operation, timeoutMs, onTimeout) {
   return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
@@ -6270,7 +6397,7 @@ function withTimeout(operation, timeoutMs, onTimeout) {
     });
   });
 }
-var TESSERACT_LANGUAGES, BUILTIN_OCR_LANGUAGES, DEFAULT_TESSERACT_TIMEOUT_MS = 30000;
+var TESSERACT_LANGUAGES, BUILTIN_OCR_LANGUAGES, DEFAULT_TESSERACT_TIMEOUT_MS = 30000, MIN_LEPTONICA_SIDE_PIXELS = 3;
 var init_ocr_engines = __esm(() => {
   TESSERACT_LANGUAGES = {
     ko: "kor",
@@ -6479,8 +6606,8 @@ function createDefaultParserRegistry(options = {}) {
   const kordocOptions = {
     ...options.kordoc,
     images: ocrEnabled,
-    ...options.kordoc?.ocr === undefined && ocrEnabled ? {
-      ocr: builtinCovers ? true : createTesseractOcrProvider({
+    ...options.kordoc?.ocr === undefined ? {
+      ocr: !ocrEnabled ? false : builtinCovers ? true : createTesseractOcrProvider({
         languages,
         timeoutMs: options.ocr?.timeoutMs,
         cachePath: options.ocr?.cachePath
@@ -6618,6 +6745,23 @@ async function syncParsedMirrors(options) {
           checkpoint();
         continue;
       }
+      const tooSmallImage = standaloneImageTooSmallMessage(entry.virtualPath, bytes);
+      if (tooSmallImage !== undefined) {
+        deleted += removePrevious(options.root, previous, entry.virtualPath);
+        handledPrevious.add(entry.virtualPath);
+        skipped += 1;
+        recordSkip(entry, "parser-skipped");
+        diagnostics.push({
+          code: "parser-skipped",
+          severity: "warning",
+          message: tooSmallImage,
+          source: entry.virtualPath
+        });
+        sinceCheckpoint += 1;
+        if (sinceCheckpoint >= MIRROR_CHECKPOINT_EVERY)
+          checkpoint();
+        continue;
+      }
       let parsed;
       try {
         parsed = await parser.parse({ virtualPath: entry.virtualPath, sourcePath: entry.sourcePath, bytes });
@@ -6719,6 +6863,11 @@ async function detectMirrorStaleness(options) {
   }
   return diagnostics;
 }
+function standaloneImageTooSmallMessage(virtualPath, bytes) {
+  if (!STANDALONE_OCR_IMAGE_EXTENSIONS.has(normalizeExtension2(extname4(virtualPath))))
+    return;
+  return ocrImageTooSmallMessage(bytes);
+}
 function sourceReadFailure(error) {
   if (!(error instanceof Error))
     return;
@@ -6814,11 +6963,13 @@ function removeFile(path) {
   if (existsSync15(path))
     rmSync6(path, { force: true });
 }
-var DEFAULT_MAX_SOURCE_BYTES, MIRROR_CHECKPOINT_EVERY = 25, PRODUCT_ARTIFACT_FILE_NAMES, SKIP_DIR_NAMES, PARSER_FAILURE_MESSAGE = "The registered parser failed on this file; it was skipped during indexing.";
+var DEFAULT_MAX_SOURCE_BYTES, MIRROR_CHECKPOINT_EVERY = 25, PRODUCT_ARTIFACT_FILE_NAMES, SKIP_DIR_NAMES, PARSER_FAILURE_MESSAGE = "The registered parser failed on this file; it was skipped during indexing.", STANDALONE_OCR_IMAGE_EXTENSIONS;
 var init_sync = __esm(() => {
   init_source_paths();
   init_defaults();
   init_errors2();
+  init_kordoc();
+  init_ocr_engines();
   init_text();
   init_index_store();
   init_paths();
@@ -6846,6 +6997,7 @@ var init_sync = __esm(() => {
     "GrShaderCache",
     "ShaderCache"
   ]);
+  STANDALONE_OCR_IMAGE_EXTENSIONS = new Set(KORDOC_IMAGE_EXTENSIONS);
 });
 
 // src/observability/run-log.ts
@@ -7711,8 +7863,36 @@ class RetrievalMethodRegistry {
   }
 }
 
+// src/cloud/config.ts
+function normalizeBaseUrl(value) {
+  const trimmed = value.trim();
+  let end = trimmed.length;
+  while (end > 0 && trimmed.charCodeAt(end - 1) === 47)
+    end--;
+  return trimmed.slice(0, end);
+}
+function resolveBaseUrl(env) {
+  const configured = env[AUTORAG_BASE_URL_ENV];
+  const value = typeof configured === "string" && configured.trim() !== "" ? configured : DEFAULT_BASE_URL;
+  return normalizeBaseUrl(value);
+}
+var PROVIDER_ID = "autorag", PROVIDER_NAME = "AutoRAG", DEFAULT_BASE_URL = "https://api.dazziapp.com", AUTORAG_BASE_URL_ENV = "AUTORAG_BASE_URL", AUTORAG_API_KEY_ENV = "AUTORAG_API_KEY", API_PATH = "/v1", MODELS_PATH = "/v1/models", AUTHORIZE_PATH = "/desktop/authorize", TOKEN_PATH = "/api/desktop/token", AUTORAG_INPUT_LIMITS, OAUTH_CLIENT_ID = "agent", API_KEY_CONFIG_VALUE;
+var init_config = __esm(() => {
+  AUTORAG_INPUT_LIMITS = {
+    maxRequestBytes: 3500000,
+    images: { resize: { maxBytes: 1e6 } }
+  };
+  API_KEY_CONFIG_VALUE = `$${AUTORAG_API_KEY_ENV}`;
+});
+
 // src/retrieval/rerank.ts
 import { OpenRouter } from "@openrouter/sdk";
+function defaultRerankModel(provider) {
+  return provider === PROVIDER_ID ? DEFAULT_AUTORAG_RERANK_MODEL : DEFAULT_RERANK_MODEL;
+}
+function defaultRerankApiKeyEnv(provider) {
+  return provider === PROVIDER_ID ? DEFAULT_AUTORAG_RERANK_API_KEY_ENV : DEFAULT_RERANK_API_KEY_ENV;
+}
 function createReranker(config) {
   if (config === false || config === undefined)
     return;
@@ -7720,30 +7900,36 @@ function createReranker(config) {
   if (!SUPPORTED_RERANK_PROVIDERS.includes(provider)) {
     throw new Error(`Unsupported rerank provider "${provider}"; supported providers: ${SUPPORTED_RERANK_PROVIDERS.join(", ")}`);
   }
-  return new OpenRouterReranker(config);
+  return new OpenRouterReranker({ ...config, provider });
+}
+function autoragApiBaseUrl(env) {
+  const root = resolveBaseUrl(env);
+  return root.endsWith(API_PATH) ? root : `${root}${API_PATH}`;
 }
 
 class OpenRouterReranker {
   model;
-  provider = DEFAULT_RERANK_PROVIDER;
+  provider;
   client;
   unavailableReason;
   constructor(options = {}) {
-    this.model = options.model ?? DEFAULT_RERANK_MODEL;
+    this.provider = options.provider ?? DEFAULT_RERANK_PROVIDER;
+    this.model = options.model ?? defaultRerankModel(this.provider);
     if (options.client !== undefined) {
       this.client = options.client;
       return;
     }
-    const apiKeyEnv = options.apiKeyEnv ?? DEFAULT_RERANK_API_KEY_ENV;
     const env = options.env ?? process.env;
+    const apiKeyEnv = options.apiKeyEnv ?? defaultRerankApiKeyEnv(this.provider);
     const apiKey = options.apiKey ?? env[apiKeyEnv];
     if (apiKey === undefined || apiKey.length === 0) {
       this.unavailableReason = `no API key: set ${apiKeyEnv} or configure rerank.apiKeyEnv`;
       return;
     }
+    const baseUrl = options.baseUrl ?? (this.provider === PROVIDER_ID ? autoragApiBaseUrl(env) : undefined);
     const sdkOptions = { apiKey };
-    if (options.baseUrl !== undefined)
-      sdkOptions.serverURL = options.baseUrl;
+    if (baseUrl !== undefined)
+      sdkOptions.serverURL = baseUrl;
     if (options.timeoutMs !== undefined)
       sdkOptions.timeoutMs = options.timeoutMs;
     const sdk = new OpenRouter(sdkOptions);
@@ -7808,9 +7994,10 @@ class OpenRouterReranker {
     return reranked;
   }
 }
-var DEFAULT_RERANK_MODEL = "voyageai/rerank-3-lite", DEFAULT_RERANK_PROVIDER = "openrouter", DEFAULT_RERANK_API_KEY_ENV = "OPENROUTER_API_KEY", DEFAULT_RERANK_TOP_N = 25, SUPPORTED_RERANK_PROVIDERS;
+var DEFAULT_RERANK_MODEL = "voyageai/rerank-3-lite", DEFAULT_RERANK_PROVIDER = "openrouter", DEFAULT_RERANK_API_KEY_ENV = "OPENROUTER_API_KEY", DEFAULT_AUTORAG_RERANK_MODEL = "qwen/qwen3-reranker-8b", DEFAULT_AUTORAG_RERANK_API_KEY_ENV = "AUTORAG_API_KEY", DEFAULT_RERANK_TOP_N = 25, SUPPORTED_RERANK_PROVIDERS;
 var init_rerank = __esm(() => {
-  SUPPORTED_RERANK_PROVIDERS = [DEFAULT_RERANK_PROVIDER];
+  init_config();
+  SUPPORTED_RERANK_PROVIDERS = [DEFAULT_RERANK_PROVIDER, PROVIDER_ID];
 });
 
 // src/retrieval/selection.ts
@@ -9029,22 +9216,219 @@ var init_fsearch_search_tool = __esm(() => {
   });
 });
 
-// src/cloud/config.ts
-function normalizeBaseUrl(value) {
-  const trimmed = value.trim();
-  let end = trimmed.length;
-  while (end > 0 && trimmed.charCodeAt(end - 1) === 47)
-    end--;
-  return trimmed.slice(0, end);
+// src/cloud/jev-backend.ts
+import {
+  BackendError
+} from "jev-use";
+
+class AutoragJevBackend {
+  name = "autorag";
+  apiKey;
+  baseUrl;
+  defaultModel;
+  timeoutMs;
+  maxRetries;
+  fetchImpl;
+  constructor(options = {}) {
+    const env = options.env ?? process.env;
+    const apiKey = options.apiKey ?? env[AUTORAG_API_KEY_ENV];
+    if (apiKey === undefined || apiKey.trim() === "") {
+      throw new Error(`jev.backend "autorag" needs ${AUTORAG_API_KEY_ENV}.`);
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = options.baseUrl ?? resolveBaseUrl(env);
+    this.defaultModel = options.defaultModel ?? AUTORAG_DEFAULT_JEV_MODEL;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.fetchImpl = options.fetchImpl;
+  }
+  async judge(request) {
+    const model = request.model ?? this.defaultModel;
+    const body = toNativeBody(request.state, request.questions, model);
+    const started = Date.now();
+    const response = await this.postJson(`${this.baseUrl}${JEV_PATH}`, body);
+    return {
+      answers: parseNativeAnswers(this.name, response.answers, request.questions),
+      model: response.model ?? model,
+      latencyMs: Date.now() - started,
+      usage: {
+        inputTokens: response.usage?.input_tokens,
+        outputTokens: response.usage?.output_tokens
+      }
+    };
+  }
+  async postJson(url, body) {
+    const doFetch = this.fetchImpl ?? fetch;
+    let lastError;
+    for (let attempt = 0;attempt <= this.maxRetries; attempt += 1) {
+      if (attempt > 0)
+        await sleep3(retryDelay(attempt, lastError));
+      const controller = new AbortController;
+      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const response = await doFetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+        if (response.ok)
+          return await response.json();
+        const message = await extractErrorMessage(response);
+        lastError = new BackendError(this.name, `HTTP ${response.status}: ${message}`, response.status);
+        lastError.retryAfterMs = parseRetryAfter(response);
+        if (!isRetryable(response.status) || attempt === this.maxRetries)
+          throw lastError;
+      } catch (error) {
+        if (error instanceof BackendError) {
+          if (attempt === this.maxRetries || !isRetryable(error.status))
+            throw error;
+          continue;
+        }
+        const aborted = error?.name === "AbortError";
+        lastError = new BackendError(this.name, aborted ? `request timed out after ${this.timeoutMs}ms` : `network error: ${String(error)}`, undefined, error);
+        if (attempt === this.maxRetries)
+          throw lastError;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw lastError ?? new BackendError(this.name, "unreachable");
+  }
 }
-function resolveBaseUrl(env) {
-  const configured = env[AUTORAG_BASE_URL_ENV];
-  const value = typeof configured === "string" && configured.trim() !== "" ? configured : DEFAULT_BASE_URL;
-  return normalizeBaseUrl(value);
+function serializeState(state) {
+  return typeof state === "string" ? state : JSON.stringify(state);
 }
-var PROVIDER_ID = "autorag", PROVIDER_NAME = "AutoRAG", DEFAULT_BASE_URL = "https://api.dazziapp.com", AUTORAG_BASE_URL_ENV = "AUTORAG_BASE_URL", AUTORAG_API_KEY_ENV = "AUTORAG_API_KEY", API_PATH = "/v1", MODELS_PATH = "/v1/models", AUTHORIZE_PATH = "/desktop/authorize", TOKEN_PATH = "/api/desktop/token", OAUTH_CLIENT_ID = "agent", API_KEY_CONFIG_VALUE;
-var init_config = __esm(() => {
-  API_KEY_CONFIG_VALUE = `$${AUTORAG_API_KEY_ENV}`;
+function toNativeQuestion(question) {
+  switch (question.type) {
+    case "noul":
+      return {
+        type: "noul",
+        instructions: question.question,
+        ...question.criteria ? { criteria: question.criteria } : {}
+      };
+    case "choice":
+      return {
+        type: "choice",
+        instructions: question.question,
+        criteria: Object.fromEntries(optionEntries(question.options ?? []).map(([label, meaning]) => [label, meaning || label]))
+      };
+    case "score":
+      return {
+        type: "score",
+        instructions: question.question,
+        criteria: question.levels ?? []
+      };
+  }
+}
+function toNativeBody(state, questions, model) {
+  return {
+    model,
+    state: serializeState(state),
+    questions: Object.fromEntries(questions.map((question) => [question.id, toNativeQuestion(question)]))
+  };
+}
+function parseNativeAnswers(backend, answers, questions) {
+  if (!answers || typeof answers !== "object") {
+    throw new BackendError(backend, "response has no answers object");
+  }
+  const byId = answers;
+  return questions.map((question) => parseNativeAnswer(backend, question, byId[question.id]));
+}
+function parseNativeAnswer(backend, question, answer) {
+  if (!answer) {
+    throw new BackendError(backend, `response missing answer for question "${question.id}"`);
+  }
+  switch (question.type) {
+    case "noul":
+      return {
+        answer: numberOrThrow(backend, question.id, answer.noul),
+        confidence: answer.confidence
+      };
+    case "choice":
+      return {
+        answer: stringOrThrow(backend, question.id, answer.choice),
+        confidence: answer.confidence,
+        distribution: answer.probabilities
+      };
+    case "score":
+      return {
+        answer: numberOrThrow(backend, question.id, answer.score),
+        confidence: answer.confidence,
+        distribution: answer.probabilities,
+        legend: answer.legend
+      };
+  }
+}
+function optionEntries(options) {
+  return Array.isArray(options) ? options.map((label) => [label, ""]) : Object.entries(options);
+}
+function numberOrThrow(backend, id, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new BackendError(backend, `answer "${id}" has no numeric value`);
+  }
+  return value;
+}
+function stringOrThrow(backend, id, value) {
+  if (typeof value !== "string" || !value) {
+    throw new BackendError(backend, `answer "${id}" has no choice value`);
+  }
+  return value;
+}
+function isRetryable(status) {
+  if (status === undefined)
+    return true;
+  return status === 408 || status === 429 || status >= 500;
+}
+function retryDelay(attempt, lastError) {
+  if (lastError?.retryAfterMs !== undefined)
+    return Math.min(lastError.retryAfterMs, 60000);
+  const base = Math.min(RETRY_BASE_MS * 2 ** (attempt - 1), RETRY_MAX_MS);
+  return base * (1 + Math.random() * 0.25);
+}
+function parseRetryAfter(response) {
+  const milliseconds = response.headers.get("retry-after-ms");
+  if (milliseconds && Number.isFinite(Number(milliseconds)))
+    return Number(milliseconds);
+  const seconds = response.headers.get("retry-after");
+  if (seconds && Number.isFinite(Number(seconds)))
+    return Number(seconds) * 1000;
+  return;
+}
+async function extractErrorMessage(response) {
+  try {
+    const data = await response.json();
+    for (const key of ["error", "message", "detail"]) {
+      const value = data[key];
+      if (typeof value === "string")
+        return value;
+      if (value && typeof value === "object") {
+        const message = value.message;
+        if (typeof message === "string")
+          return message;
+      }
+      if (Array.isArray(value) && value.length > 0) {
+        const first = value[0];
+        if (typeof first?.msg === "string")
+          return first.msg;
+      }
+    }
+    return JSON.stringify(data).slice(0, 300);
+  } catch {
+    return response.statusText || "request failed";
+  }
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var JEV_PATH, AUTORAG_DEFAULT_JEV_MODEL = "jev-1.13", DEFAULT_TIMEOUT_MS6 = 1e4, DEFAULT_MAX_RETRIES = 2, RETRY_BASE_MS = 500, RETRY_MAX_MS = 5000;
+var init_jev_backend = __esm(() => {
+  init_config();
+  JEV_PATH = `${API_PATH}/jev`;
 });
 
 // src/cloud/errors.ts
@@ -9175,7 +9559,8 @@ function mapServerModel(entry) {
     cost: readPricing(entry.pricing),
     reasoning: entry.reasoning === true,
     contextWindow: readPositiveNumber(entry.context_window) ?? DEFAULT_CONTEXT_WINDOW,
-    maxTokens: readPositiveNumber(entry.max_output_tokens) ?? DEFAULT_MAX_TOKENS
+    maxTokens: readPositiveNumber(entry.max_output_tokens) ?? DEFAULT_MAX_TOKENS,
+    inputLimits: AUTORAG_INPUT_LIMITS
   };
 }
 function buildStoreEntry(models, providerId, baseUrl) {
@@ -9214,7 +9599,8 @@ function modelsFromStore(stored) {
       cost: entry.cost,
       reasoning: entry.reasoning,
       contextWindow: entry.contextWindow,
-      maxTokens: entry.maxTokens
+      maxTokens: entry.maxTokens,
+      inputLimits: AUTORAG_INPUT_LIMITS
     });
   }
   return models;
@@ -9622,69 +10008,456 @@ var init_provider = __esm(() => {
   init_oauth_login();
 });
 
-// src/agent/pi-session.ts
-import { join as join21 } from "node:path";
-import { streamSimple as compatStreamSimple } from "@earendil-works/pi-ai/compat";
-import {
-  createAgentSession,
-  createAgentSessionFromServices,
-  createAgentSessionRuntime,
-  createAgentSessionServices,
-  DefaultResourceLoader,
-  getAgentDir,
-  ModelRuntime,
-  SessionManager,
-  SettingsManager
-} from "@earendil-works/pi-coding-agent";
-function resolveInteractiveTuiMode(settingsManager) {
-  const saved = settingsManager.getProjectSettings().tuiMode ?? settingsManager.getGlobalSettings().tuiMode;
-  return saved ?? "regular";
-}
-function toToolDefinition(tool) {
-  return {
-    name: tool.name,
-    label: tool.label,
-    description: tool.description,
-    parameters: tool.parameters,
-    ...tool.prepareArguments === undefined ? {} : { prepareArguments: tool.prepareArguments },
-    execute: async (toolCallId, params, signal, onUpdate) => {
-      return tool.execute(toolCallId, params, signal, onUpdate);
-    }
+// src/agent/context-token-guard.ts
+import { calculateContextTokens, estimateTokens } from "@earendil-works/pi-coding-agent";
+function createContextTokenGuardedTransform(model, base, fixedOverheadTokens = () => 0) {
+  return async (messages) => {
+    const transformed = base === undefined ? messages : await base(messages);
+    const currentModel = typeof model === "function" ? model() : model;
+    return guardAgentContextMessages(currentModel, transformed, transformed === messages, fixedOverheadTokens());
   };
 }
-function modelConfig(model, configuredApiKey) {
-  return {
-    name: model.name,
-    baseUrl: model.baseUrl,
-    api: model.api,
-    ...configuredApiKey === undefined ? {} : { apiKey: configuredApiKey },
-    authHeader: false,
-    streamSimple: (requestModel, context, options) => compatStreamSimple(requestModel, context, {
-      ...options,
-      ...configuredApiKey === EMBEDDED_AUTH_MARKER ? { apiKey: undefined } : {}
-    }),
-    models: [
-      {
-        id: model.id,
-        name: model.name,
-        reasoning: model.reasoning,
-        input: [...model.input],
-        cost: model.cost,
-        contextWindow: model.contextWindow,
-        maxTokens: model.maxTokens,
-        ...model.thinkingLevelMap === undefined ? {} : { thinkingLevelMap: model.thinkingLevelMap }
+function guardAgentContextMessages(model, messages, useReportedUsage = true, fixedOverheadTokens = 0) {
+  if (model === undefined || !Number.isFinite(model.contextWindow) || model.contextWindow <= 0 || messages.length === 0) {
+    return messages;
+  }
+  const usableContext = Math.floor(model.contextWindow / CONTEXT_HEADROOM);
+  const outputReserve = Math.min(usableContext, Number.isFinite(model.maxTokens) ? Math.max(0, model.maxTokens) : 0);
+  const inputBudget = Math.max(0, usableContext - outputReserve);
+  const budget = Math.max(0, inputBudget - fixedOverheadTokens);
+  const reported = useReportedUsage && findLastAssistantUsage(messages) !== undefined;
+  if (estimateContextMessageTokens(messages, useReportedUsage) <= (reported ? inputBudget : budget)) {
+    return messages;
+  }
+  const candidates = [];
+  const candidateIndexes = [];
+  const base = messages.slice();
+  for (const [index, message] of base.entries()) {
+    const text = textContent(message);
+    if (text === undefined)
+      continue;
+    const section = parseCandidateSection(message, text);
+    if (section === undefined)
+      continue;
+    candidates.push(section);
+    candidateIndexes.push(index);
+    base[index] = replaceTextContent(message, `${section.prefix}${section.suffix}`);
+  }
+  let guarded = messages;
+  if (candidates.length > 0) {
+    const fixedTokens = estimateContextMessageTokens(base, false);
+    const maximumOmitted = candidates.reduce((total, section) => total + section.blocks.length, 0);
+    const omissionMarker = (count) => `
+
+${GUARD_MARKER} Retrieval candidates omitted: ${count}.
+`;
+    let remaining = Math.max(0, budget - fixedTokens - Math.ceil(omissionMarker(maximumOmitted).length / 4));
+    const kept = candidates.map(() => []);
+    let omitted = 0;
+    let firstOmitted = -1;
+    for (const [sectionIndex, section] of candidates.entries()) {
+      for (const block of section.blocks) {
+        const tokens = Math.max(1, Math.ceil(block.length / 4));
+        if (tokens <= remaining) {
+          kept[sectionIndex]?.push(block);
+          remaining -= tokens;
+          continue;
+        }
+        omitted += section.blocks.length - (kept[sectionIndex]?.length ?? 0);
+        for (const later of candidates.slice(sectionIndex + 1))
+          omitted += later.blocks.length;
+        firstOmitted = sectionIndex;
+        break;
       }
-    ]
-  };
+      if (firstOmitted !== -1)
+        break;
+    }
+    if (omitted > 0) {
+      const candidateByMessage = new Map;
+      for (const [sectionIndex, messageIndex] of candidateIndexes.entries())
+        candidateByMessage.set(messageIndex, sectionIndex);
+      guarded = base.map((message, index) => {
+        const sectionIndex = candidateByMessage.get(index);
+        if (sectionIndex === undefined)
+          return message;
+        const section = candidates[sectionIndex];
+        const marker = sectionIndex === firstOmitted ? omissionMarker(omitted) : "";
+        return replaceTextContent(message, `${section.prefix}${kept[sectionIndex]?.join("") ?? ""}${marker}${section.suffix}`);
+      });
+    }
+  }
+  if (estimateContextMessageTokens(guarded, false) <= budget && guarded !== messages)
+    return guarded;
+  return trimFixedContext(guarded, budget);
 }
-async function configureModelRuntime(modelRuntime, model, apiKey, providerApiKeys) {
-  if (model !== undefined) {
-    const configuredKey = apiKey ?? providerApiKeys?.[model.provider];
-    if (modelRuntime.getModel(model.provider, model.id) === undefined) {
-      modelRuntime.registerProvider(model.provider, modelConfig(model, configuredKey ?? EMBEDDED_AUTH_MARKER));
+function estimateContextMessageTokens(messages, useReportedUsage = false) {
+  if (useReportedUsage) {
+    const usage = findLastAssistantUsage(messages);
+    if (usage !== undefined) {
+      return calculateContextTokens(usage.usage) + messages.slice(usage.index + 1).reduce((total, message) => total + estimateMessageTokens(message), 0);
     }
   }
-  const keys = new Map;
+  return messages.reduce((total, message) => total + estimateMessageTokens(message), 0);
+}
+function trimFixedContext(messages, inputBudget) {
+  const trimmed = messages.slice();
+  const lastIndex = trimmed.length - 1;
+  const shrinkable = trimmed.map((message, index) => ({ message, index })).filter(({ index, message }) => index !== lastIndex && message.role !== "system");
+  for (const { message, index } of shrinkable) {
+    const replacement = replaceMessageWithMarker(message);
+    if (replacement === message || estimateMessageTokens(replacement) >= estimateMessageTokens(message))
+      continue;
+    trimmed[index] = replacement;
+    if (estimateContextMessageTokens(trimmed, false) <= inputBudget)
+      return trimmed;
+  }
+  const lastMessage = trimmed[lastIndex];
+  if (lastMessage !== undefined && lastMessage.role !== "system") {
+    const replacement = replaceMessageWithMarker(lastMessage);
+    if (replacement !== lastMessage) {
+      trimmed[lastIndex] = replacement;
+      if (estimateContextMessageTokens(trimmed, false) <= inputBudget)
+        return trimmed;
+    }
+    const fixedWithoutLast = trimmed.reduce((total, message, index) => index === lastIndex ? total : total + estimateMessageTokens(message), 0);
+    if (fixedWithoutLast < inputBudget) {
+      const fitted = fitMessageToTokens(lastMessage, inputBudget - fixedWithoutLast);
+      if (fitted !== lastMessage) {
+        trimmed[lastIndex] = fitted;
+        if (estimateContextMessageTokens(trimmed, false) <= inputBudget)
+          return trimmed;
+      }
+    }
+  }
+  for (const [index, message] of trimmed.entries()) {
+    if (message.role !== "system")
+      continue;
+    const replacement = replaceMessageWithMarker(message);
+    if (replacement === message || estimateMessageTokens(replacement) >= estimateMessageTokens(message))
+      continue;
+    trimmed[index] = replacement;
+    if (estimateContextMessageTokens(trimmed, false) <= inputBudget)
+      return trimmed;
+  }
+  return trimmed;
+}
+function fitMessageToTokens(message, maxTokens) {
+  const original = textContent(message);
+  if (original === undefined)
+    return message;
+  const marker = `
+
+${GUARD_MARKER}
+`;
+  let low = 0;
+  let high = original.length;
+  let best = replaceTextContent(message, marker);
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const candidate = replaceTextContent(message, excerpt(original, middle, marker));
+    if (estimateMessageTokens(candidate) <= maxTokens) {
+      best = candidate;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return best;
+}
+function excerpt(text, maxChars, marker) {
+  if (text.length <= maxChars)
+    return text;
+  const available = Math.max(0, maxChars - marker.length);
+  const head = Math.ceil(available * 0.7);
+  const tail = Math.max(0, available - head);
+  return `${text.slice(0, head)}${marker}${tail > 0 ? text.slice(-tail) : ""}`;
+}
+function replaceMessageWithMarker(message) {
+  return replaceTextContent(message, `
+
+${GUARD_MARKER}
+`);
+}
+function estimateMessageTokens(message) {
+  if (message.role === "system")
+    return estimateSystemMessageTokens(message);
+  const estimate = estimateTokens(message);
+  return message.role === "toolResult" ? estimate + Math.ceil(message.toolName.length / 4) : estimate;
+}
+function estimateSystemMessageTokens(message) {
+  let chars = typeof message.content === "string" ? message.content.length : 0;
+  if (Array.isArray(message.content)) {
+    for (const block of message.content) {
+      if (block.type === "text")
+        chars += block.text.length;
+      else if (block.type === "image")
+        chars += 4800;
+    }
+  }
+  chars += JSON.stringify(message.sections ?? {}).length;
+  chars += JSON.stringify(message.toolsAdded ?? []).length;
+  chars += JSON.stringify(message.toolsRemoved ?? []).length;
+  return Math.ceil(chars / 4);
+}
+function findLastAssistantUsage(messages) {
+  for (let index = messages.length - 1;index >= 0; index--) {
+    const message = messages[index];
+    if (message?.role !== "assistant" || message.stopReason === "aborted" || message.stopReason === "error")
+      continue;
+    if (calculateContextTokens(message.usage) > 0)
+      return { index, usage: message.usage };
+  }
+  return;
+}
+function textContent(message) {
+  if (message.role === "system") {
+    if (typeof message.content === "string")
+      return message.content;
+    return message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+  }
+  if (message.role === "user" || message.role === "toolResult") {
+    if (typeof message.content === "string")
+      return message.content;
+    let text = "";
+    for (const block of message.content) {
+      if (block.type !== "text")
+        return;
+      text += block.text;
+    }
+    return text;
+  }
+  if (message.role === "assistant") {
+    let text = "";
+    for (const block of message.content)
+      if (block.type === "text")
+        text += block.text;
+    return text.length > 0 ? text : undefined;
+  }
+  return;
+}
+function replaceTextContent(message, text) {
+  if (message.role === "system")
+    return { ...message, content: text };
+  if (message.role === "user") {
+    if (typeof message.content === "string")
+      return { ...message, content: text };
+    return { ...message, content: [{ type: "text", text }] };
+  }
+  if (message.role === "toolResult")
+    return { ...message, content: [{ type: "text", text }] };
+  if (message.role === "assistant") {
+    const content = [];
+    let replaced = false;
+    for (const block of message.content) {
+      if (block.type !== "text") {
+        content.push(block);
+        continue;
+      }
+      if (replaced)
+        continue;
+      replaced = true;
+      content.push({ ...block, text });
+    }
+    return replaced ? { ...message, content } : message;
+  }
+  return message;
+}
+function parseCandidateSection(message, text) {
+  if (message.role === "user") {
+    const markerMatch = /(?:Baseline retrieval (?:evidence \(already gathered for you\)|context):|initial candidates:)/u.exec(text);
+    if (markerMatch === null)
+      return;
+    const sectionStart = (markerMatch.index ?? 0) + markerMatch[0].length;
+    const sectionEnd = findBaselineSectionEnd(text, sectionStart);
+    if (!/^\[e?\d+\] /mu.test(text.slice(sectionStart, sectionEnd)))
+      return;
+    return splitCandidates(text, sectionStart, sectionEnd);
+  }
+  if (message.role !== "toolResult")
+    return;
+  const isRetrieval = RETRIEVAL_TOOL_NAMES[message.toolName] === true || message.toolName.startsWith(RETRIEVAL_TOOL_PREFIX);
+  if (!isRetrieval)
+    return;
+  if (message.toolName === "jikji_find") {
+    const directiveStart = text.indexOf(`
+
+directive:`);
+    return splitCandidates(text, 0, directiveStart >= 0 ? directiveStart : text.length, /^- [^\n]*(?:\n|$)/gmu);
+  }
+  const diagnosticsStart = text.indexOf(`
+
+Diagnostics:`);
+  return splitCandidates(text, 0, diagnosticsStart >= 0 ? diagnosticsStart : text.length);
+}
+function findBaselineSectionEnd(text, startIndex) {
+  const endMarkers = [
+    `
+
+Produce the best`,
+    `
+
+Treat candidates as unverified evidence`,
+    `
+
+Formatting and content rules`
+  ];
+  const positions = endMarkers.map((marker) => text.indexOf(marker, startIndex)).filter((index) => index >= 0);
+  return positions.length > 0 ? Math.min(...positions) : text.length;
+}
+function splitCandidates(text, sectionStart, sectionEnd, pattern = /^\[e?\d+\] [^\n]*(?:\n|$)/gmu) {
+  const region = text.slice(sectionStart, sectionEnd);
+  const matches = [...region.matchAll(pattern)];
+  const firstStart = matches[0]?.index;
+  if (firstStart === undefined)
+    return;
+  const blocks = [];
+  for (const [index, match] of matches.entries()) {
+    const start = match.index ?? 0;
+    const end = index + 1 < matches.length ? matches[index + 1]?.index ?? region.length : region.length;
+    blocks.push(region.slice(start, end));
+  }
+  return {
+    prefix: text.slice(0, sectionStart) + region.slice(0, firstStart),
+    suffix: text.slice(sectionEnd),
+    blocks
+  };
+}
+var CONTEXT_HEADROOM = 1.2, GUARD_MARKER = "[AutoRAG context guard: omitted context to stay within the model context budget.]", RETRIEVAL_TOOL_PREFIX = "search_datasource_", RETRIEVAL_TOOL_NAMES;
+var init_context_token_guard = __esm(() => {
+  RETRIEVAL_TOOL_NAMES = {
+    jikji_find: true,
+    search_all_documents: true,
+    semantic_search_local_docs: true,
+    search_single_datasource_documents: true,
+    everything_search: true,
+    fsearch_search: true
+  };
+});
+
+// src/agent/request-limits.ts
+function fitRequestLimits(messages, limits) {
+  const maxBytes = limits?.maxRequestBytes;
+  const maxImages = limits?.images?.maxPerRequest;
+  if (maxBytes === undefined && maxImages === undefined)
+    return;
+  const images = imageLocations(messages);
+  if (images.length === 0)
+    return;
+  let keptImages = images.length;
+  let bytes = maxBytes === undefined ? 0 : Buffer.byteLength(JSON.stringify(messages));
+  const dropped = [];
+  for (const image of images) {
+    const overCount = maxImages !== undefined && keptImages > maxImages;
+    const overBytes = maxBytes !== undefined && bytes > maxBytes;
+    if (!overCount && !overBytes)
+      break;
+    dropped.push(image);
+    keptImages--;
+    bytes -= image.bytes - NOTE_BYTES;
+  }
+  if (dropped.length === 0)
+    return;
+  const byMessage = new Map;
+  for (const { message, block } of dropped) {
+    const blocks = byMessage.get(message) ?? new Set;
+    blocks.add(block);
+    byMessage.set(message, blocks);
+  }
+  return messages.map((message, index) => {
+    const blocks = byMessage.get(index);
+    if (blocks === undefined)
+      return message;
+    const content = message.content.map((part, block) => blocks.has(block) ? { type: "text", text: IMAGE_OMITTED_NOTE } : part);
+    return { ...message, content };
+  });
+}
+function imageLocations(messages) {
+  const locations = [];
+  messages.forEach((message, index) => {
+    const content = message.content;
+    if (!Array.isArray(content))
+      return;
+    content.forEach((part, block) => {
+      if (!isImage(part))
+        return;
+      locations.push({ message: index, block, bytes: Buffer.byteLength(JSON.stringify(part)) });
+    });
+  });
+  return locations;
+}
+function isImage(part) {
+  return typeof part === "object" && part !== null && part.type === "image";
+}
+var IMAGE_OMITTED_NOTE = "[Image omitted from this request to stay within the model provider's request limits. Read the file again if you still need to see it.]", NOTE_BYTES;
+var init_request_limits = __esm(() => {
+  NOTE_BYTES = Buffer.byteLength(JSON.stringify({ type: "text", text: IMAGE_OMITTED_NOTE }));
+});
+
+// src/agent/pi-session.ts
+import { join as join21 } from "node:path";
+import { streamSimple as compatStreamSimple } from "@earendil-works/pi-ai/compat";
+import {
+  createAgentSession,
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  createAgentSessionServices,
+  DefaultResourceLoader,
+  getAgentDir,
+  ModelRuntime,
+  SessionManager,
+  SettingsManager
+} from "@earendil-works/pi-coding-agent";
+import { getKeybindings, matchesKey } from "@earendil-works/pi-tui";
+function resolveInteractiveTuiMode(settingsManager) {
+  const saved = settingsManager.getProjectSettings().tuiMode ?? settingsManager.getGlobalSettings().tuiMode;
+  return saved ?? "regular";
+}
+function toToolDefinition(tool) {
+  return {
+    name: tool.name,
+    label: tool.label,
+    description: tool.description,
+    parameters: tool.parameters,
+    ...tool.prepareArguments === undefined ? {} : { prepareArguments: tool.prepareArguments },
+    execute: async (toolCallId, params, signal, onUpdate) => {
+      return tool.execute(toolCallId, params, signal, onUpdate);
+    }
+  };
+}
+function modelConfig(model, configuredApiKey) {
+  return {
+    name: model.name,
+    baseUrl: model.baseUrl,
+    api: model.api,
+    ...configuredApiKey === undefined ? {} : { apiKey: configuredApiKey },
+    authHeader: false,
+    streamSimple: (requestModel, context, options) => compatStreamSimple(requestModel, context, {
+      ...options,
+      ...configuredApiKey === EMBEDDED_AUTH_MARKER ? { apiKey: undefined } : {}
+    }),
+    models: [
+      {
+        id: model.id,
+        name: model.name,
+        reasoning: model.reasoning,
+        input: [...model.input],
+        cost: model.cost,
+        contextWindow: model.contextWindow,
+        maxTokens: model.maxTokens,
+        ...model.inputLimits === undefined ? {} : { inputLimits: model.inputLimits },
+        ...model.thinkingLevelMap === undefined ? {} : { thinkingLevelMap: model.thinkingLevelMap }
+      }
+    ]
+  };
+}
+async function configureModelRuntime(modelRuntime, model, apiKey, providerApiKeys) {
+  if (model !== undefined) {
+    const configuredKey = apiKey ?? providerApiKeys?.[model.provider];
+    if (modelRuntime.getModel(model.provider, model.id) === undefined) {
+      modelRuntime.registerProvider(model.provider, modelConfig(model, configuredKey ?? EMBEDDED_AUTH_MARKER));
+    }
+  }
+  const keys = new Map;
   if (model !== undefined && apiKey !== undefined)
     keys.set(model.provider, apiKey);
   for (const [provider, key] of Object.entries(providerApiKeys ?? {}))
@@ -9692,20 +10465,47 @@ async function configureModelRuntime(modelRuntime, model, apiKey, providerApiKey
   for (const [provider, key] of keys)
     await modelRuntime.setRuntimeApiKey(provider, key);
 }
+function enforceRequestLimits(pi) {
+  pi.on("context", (event, ctx) => {
+    const messages = fitRequestLimits(event.messages, ctx.model?.inputLimits);
+    return messages === undefined ? undefined : { messages };
+  });
+}
+function guardContext(pi, contextTransform) {
+  pi.on("context", async (event, ctx) => {
+    const activeTools = new Set(pi.getActiveTools());
+    const toolDeclarations = pi.getAllTools().filter((tool) => activeTools.has(tool.name)).map(({ name, description, parameters }) => ({ name, description, parameters }));
+    const fixedOverheadTokens = Math.ceil((ctx.getSystemPrompt().length + JSON.stringify(toolDeclarations).length) / 4);
+    return {
+      messages: await createContextTokenGuardedTransform(ctx.model, contextTransform, () => fixedOverheadTokens)(event.messages)
+    };
+  });
+}
 function createAutoRAGExtension(getSystemPrompt, contextTransform) {
   return (pi) => {
     pi.on("before_agent_start", () => ({ systemPrompt: getSystemPrompt() }));
-    if (contextTransform !== undefined) {
-      pi.on("context", async (event) => ({ messages: await contextTransform(event.messages) }));
-    }
+    guardContext(pi, contextTransform);
+    enforceRequestLimits(pi);
+  };
+}
+function interactiveKeyOf(data) {
+  const bindings = getKeybindings();
+  const keysOf = (action, fallback) => {
+    const keys = bindings.getKeys(action);
+    return keys.length > 0 ? keys : [fallback];
   };
+  const windows = process.platform === "win32" || process.platform === "linux" && Boolean(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
+  if (keysOf("app.interrupt", "escape").some((key) => matchesKey(data, key)))
+    return "interrupt";
+  if (keysOf("app.message.followUp", windows ? "ctrl+q" : "alt+enter").some((key) => matchesKey(data, key)))
+    return "followUp";
+  return;
 }
-function createAutoRAGInteractiveExtension(getSystemPrompt, contextTransform, onQuery, updateNotice) {
+function createAutoRAGInteractiveExtension(getSystemPrompt, contextTransform, options, updateNotice) {
   return (pi) => {
     pi.on("before_agent_start", () => ({ systemPrompt: getSystemPrompt() }));
-    if (contextTransform !== undefined) {
-      pi.on("context", async (event) => ({ messages: await contextTransform(event.messages) }));
-    }
+    guardContext(pi, contextTransform);
+    enforceRequestLimits(pi);
     if (updateNotice !== undefined) {
       pi.on("session_start", () => {
         updateNotice().then((text) => {
@@ -9721,20 +10521,37 @@ function createAutoRAGInteractiveExtension(getSystemPrompt, contextTransform, on
         });
       });
     }
-    pi.on("input", async (event) => {
-      const query = event.text.trim();
-      if (event.source !== "interactive" || query.length === 0 || query.startsWith("/"))
+    const { onInput, isSearchRunning, onKey } = options;
+    if (onKey !== undefined) {
+      pi.on("session_start", (_event, ctx) => {
+        ctx.ui.onTerminalInput((data) => {
+          const key = interactiveKeyOf(data);
+          return key !== undefined && onKey(key) ? { consume: true } : undefined;
+        });
+      });
+    }
+    pi.on("input", (event) => {
+      const text = event.text.trim();
+      if (event.source !== "interactive" || text.length === 0)
+        return;
+      if (text.startsWith("/") && isSearchRunning?.() !== true)
         return;
+      let disposition;
       try {
-        await onQuery(query, pi);
+        disposition = onInput({ text, images: event.images, streamingBehavior: event.streamingBehavior }, pi);
       } catch (error) {
         pi.sendMessage({
           customType: "autorag.error",
           content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
           display: true
-        });
-      }
-      return { action: "handled" };
+        }, { triggerTurn: false });
+        return { action: "handled" };
+      }
+      return disposition.kind === "steer" ? {
+        action: "transform",
+        text: disposition.text,
+        ...event.images === undefined ? {} : { images: event.images }
+      } : { action: "handled" };
     });
   };
 }
@@ -9814,7 +10631,7 @@ async function createAutoRAGPiInteractiveRuntime(options) {
       settingsManager,
       resourceLoaderOptions: {
         extensionFactories: [
-          createAutoRAGInteractiveExtension(options.getSystemPrompt, options.contextTransform, options.onQuery, options.updateNotice),
+          createAutoRAGInteractiveExtension(options.getSystemPrompt, options.contextTransform, { onInput: options.onInput, isSearchRunning: options.isSearchRunning, onKey: options.onKey }, options.updateNotice),
           ...options.extensionFactories ?? []
         ],
         systemPrompt: options.getSystemPrompt(),
@@ -9849,6 +10666,8 @@ async function createAutoRAGPiInteractiveRuntime(options) {
 var PI_BUILTIN_TOOL_NAMES, EMBEDDED_AUTH_MARKER = "<autorag-embedded-model>";
 var init_pi_session = __esm(() => {
   init_provider();
+  init_context_token_guard();
+  init_request_limits();
   PI_BUILTIN_TOOL_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 });
 
@@ -9858,12 +10677,26 @@ import { Type as Type6 } from "typebox";
 function createJevJudge(options = {}) {
   let client;
   return async (state, questions, callOptions = {}) => {
-    client ??= new Jev({
-      ...options.backend !== undefined ? { backend: options.backend } : {},
-      ...options.env !== undefined ? { env: options.env } : {},
-      ...options.model !== undefined ? { model: options.model } : {},
-      ...options.confidenceThreshold !== undefined ? { confidenceThreshold: options.confidenceThreshold } : {}
-    });
+    if (client === undefined) {
+      const env = options.env ?? process.env;
+      const explicit = options.backend;
+      let backend;
+      if (typeof explicit === "string") {
+        backend = explicit === "autorag" ? new AutoragJevBackend({ env }) : explicit;
+      } else if (explicit !== undefined) {
+        backend = explicit;
+      } else if (env.JEV_BACKEND?.toLowerCase() === "autorag") {
+        backend = new AutoragJevBackend({ env });
+      } else {
+        backend = undefined;
+      }
+      client = new Jev({
+        ...backend !== undefined ? { backend } : {},
+        ...options.env !== undefined ? { env: options.env } : {},
+        ...options.model !== undefined ? { model: options.model } : {},
+        ...options.confidenceThreshold !== undefined ? { confidenceThreshold: options.confidenceThreshold } : {}
+      });
+    }
     const model = options.model ?? BACKEND_DEFAULT_MODEL[client.backend.name];
     return client.judge(state, questions, {
       ...model !== undefined ? { model } : {},
@@ -9905,8 +10738,12 @@ function createJevExtension(judgeOrOptions = {}) {
 }
 var JEV_TOOL_NAME = "jev", OPENROUTER_DEFAULT_MODEL = "typesafe/jev-1.13", BACKEND_DEFAULT_MODEL, jevQuestionSchema, jevParameters;
 var init_jev_extension = __esm(() => {
+  init_jev_backend();
   init_pi_session();
-  BACKEND_DEFAULT_MODEL = { openrouter: OPENROUTER_DEFAULT_MODEL };
+  BACKEND_DEFAULT_MODEL = {
+    openrouter: OPENROUTER_DEFAULT_MODEL,
+    autorag: AUTORAG_DEFAULT_JEV_MODEL
+  };
   jevQuestionSchema = Type6.Object({
     id: Type6.Optional(Type6.String({ description: "Caller-assigned id, echoed back in the verdict" })),
     type: Type6.Union([Type6.Literal("noul"), Type6.Literal("choice"), Type6.Literal("score")], {
@@ -9948,7 +10785,7 @@ function createJikjiFindTool(provider, ledger = new EvidenceLedger) {
     label: "Jikji Find",
     description: "Discover local files via Jikji. Returns answer_paths with per-candidate next_read hints and a tool-call policy directive. Call this FIRST for local file discovery when Jikji is configured.",
     parameters: jikjiFindSchema,
-    async execute(_toolCallId, params) {
+    async execute(_toolCallId, params, signal) {
       const query = String(params.query ?? "").trim();
       if (query.length === 0) {
         return {
@@ -9971,7 +10808,8 @@ function createJikjiFindTool(provider, ledger = new EvidenceLedger) {
       }
       const { answerPack, policy, diagnostics, perRoot } = await provider.findJikji(query, {
         topK: params.topK,
-        first: params.first
+        first: params.first,
+        ...signal === undefined ? {} : { signal }
       });
       if (answerPack === undefined) {
         const diagMsg = diagnostics.length > 0 ? diagnostics.map((d) => d.message).join(" ") : "Jikji is unavailable or all roots failed.";
@@ -12285,7 +13123,7 @@ function createSearchAllDocumentsTool(provider, ledger = new EvidenceLedger) {
     label: "Search All Documents",
     description: "Search across all configured retrieval methods (posix, MinSync, datasources) and return every distinct chunk they found, with only pure duplicates removed. This is the exhaustive retrieval surface: one call can return many candidates, including several passages of the same document, so judge the evidence yourself rather than assuming it was pre-filtered. Authority is server-configured; tool arguments can only provide query, topK, and an optional narrowing scope.",
     parameters: searchAllSchema,
-    async execute(_toolCallId, params) {
+    async execute(_toolCallId, params, signal) {
       const query = params.query.trim();
       if (query.length === 0) {
         return {
@@ -12295,7 +13133,8 @@ function createSearchAllDocumentsTool(provider, ledger = new EvidenceLedger) {
       }
       const { results, diagnostics, perMethodCounts } = await provider.searchAllDocuments(query, {
         topK: params.topK,
-        scope: params.scope
+        scope: params.scope,
+        ...signal === undefined ? {} : { signal }
       });
       const evidenceIds = results.map((result) => ledger.registerResult(SEARCH_ALL_DOCUMENTS_TOOL_NAME, result));
       return {
@@ -12319,7 +13158,7 @@ Diagnostics: ${diagnostics.map((d) => `${d.source ?? "all"}:${d.code}`).join(",
   if (results.length === 0)
     return `No results.${diagnosticSummary}`;
   const rows = results.map((result, index) => {
-    const line = result.content.replace(/\s+/gu, " ").slice(0, 500);
+    const line = result.content.replace(/\s+/gu, " ");
     return `[${evidenceIds[index]}] ${result.source} score=${result.score.toFixed(4)}
 ${line}`;
   });
@@ -12350,7 +13189,7 @@ function createSearchMinSyncDocumentsTool(getMethod, resolveScope = (scope) => s
     label: "Search MinSync Documents",
     description: "Search parsed document mirrors with MinSync semantic vector retrieval. Use for conceptual and meaning-based search.",
     parameters: searchMinSyncSchema,
-    async execute(_toolCallId, params) {
+    async execute(_toolCallId, params, signal) {
       if (params.query.trim().length === 0) {
         return {
           content: [{ type: "text", text: "MinSync query was empty; no documents searched." }],
@@ -12360,7 +13199,8 @@ function createSearchMinSyncDocumentsTool(getMethod, resolveScope = (scope) => s
       const scope = resolveScope(params.scope);
       const results = await getMethod().retrieve(params.query, {
         topK: params.topK,
-        scope
+        scope,
+        ...signal === undefined ? {} : { signal }
       });
       const evidenceIds = results.map((result) => ledger.registerResult(SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME, result));
       return {
@@ -12379,7 +13219,7 @@ function formatResults2(results, evidenceIds) {
   if (results.length === 0)
     return "No MinSync results.";
   const rows = results.map((result, index) => {
-    const line = result.content.replace(/\s+/gu, " ").slice(0, 500);
+    const line = result.content.replace(/\s+/gu, " ");
     return `[${evidenceIds[index]}] ${result.source} score=${result.score.toFixed(4)}
 ${line}`;
   });
@@ -12427,7 +13267,7 @@ function createTool(provider, spec, ledger) {
     label: `Search ${spec.datasourceId}`,
     description: `Search only the "${spec.datasourceId}" datasource connection: ${spec.description} ` + `This tool spawns only this connection's CLIs and returns only this connection's hits.${scopeLine} ` + `Authority is server-configured; tool arguments can only provide query, topK, and an optional narrowing scope.`,
     parameters: searchSingleDatasourceSchema,
-    async execute(_toolCallId, params) {
+    async execute(_toolCallId, params, signal) {
       const query = params.query.trim();
       if (query.length === 0) {
         return {
@@ -12443,7 +13283,8 @@ function createTool(provider, spec, ledger) {
       }
       const { results, diagnostics } = await provider.searchSingleDatasourceDocuments(spec.datasourceId, query, {
         topK: params.topK,
-        scope: params.scope
+        scope: params.scope,
+        ...signal === undefined ? {} : { signal }
       });
       const evidenceIds = results.map((result) => ledger.registerResult(`search_datasource_${spec.datasourceId}`, result));
       return {
@@ -12467,7 +13308,7 @@ Diagnostics: ${diagnostics.map((d) => `${d.source ?? "datasource"}:${d.code}`).j
   if (results.length === 0)
     return `No datasource results.${diagnosticSummary}`;
   const rows = results.map((result, index) => {
-    const line = result.content.replace(/\s+/gu, " ").slice(0, 500);
+    const line = result.content.replace(/\s+/gu, " ");
     return `[${evidenceIds[index]}] ${result.source} score=${result.score.toFixed(4)}
 ${line}`;
   });
@@ -18030,7 +18871,7 @@ function mergeSources(merged, sources) {
       existing.source.ageSeconds ??= source.ageSeconds;
   }
 }
-function sleep3(ms, signal) {
+function sleep4(ms, signal) {
   if (ms <= 0)
     return Promise.resolve();
   let resolveFn;
@@ -18080,9 +18921,9 @@ async function searchPublicWeb(params, deadlines = {}) {
       failures.push({ provider: { id, label: id }, error });
     }
   }));
-  await Promise.race([all, sleep3(softMs, signal)]);
+  await Promise.race([all, sleep4(softMs, signal)]);
   if (!responses.some(isUseful) && failures.length < engineIds.length) {
-    await Promise.race([all, firstSuccess, sleep3(Math.max(0, hardMs - softMs), signal)]);
+    await Promise.race([all, firstSuccess, sleep4(Math.max(0, hardMs - softMs), signal)]);
   }
   straggler.abort();
   const merged = new Map;
@@ -18498,6 +19339,20 @@ class AutoRAGAgent {
   lastQuery;
   lastSessionId;
   activeRun = false;
+  interactive = {
+    run: undefined,
+    followUps: [],
+    steers: [],
+    queuedSteers: [],
+    preSessionSteers: [],
+    acceptingSteers: false,
+    harnessAbort: false,
+    userAborted: false,
+    steerInterrupt: new AbortController,
+    nextSubmitIsFollowUp: false,
+    steerTexts: new Set
+  };
+  activeRunAbort;
   modelNativeSearchAuth;
   retrievalTrace = [];
   evidenceLedger = new EvidenceLedger;
@@ -18974,9 +19829,9 @@ ${context.text}
       apiKey: resolved.apiKey,
       providerApiKeys: resolved.providerApiKeys,
       getSystemPrompt: () => systemPrompt,
-      customTools: this.tools.filter((tool) => !PI_BUILTIN_TOOL_NAMES.includes(tool.name)),
+      customTools: this.steerableTools(),
       remoteSession: this.remoteSession,
-      contextTransform: (messages) => this.withMemoryContext(messages),
+      contextTransform: (messages) => this.withMemoryContext(frameSteers(messages, this.interactive.steerTexts)),
       ...this.jevExtension !== undefined ? { extensionFactories: [this.jevExtension], extensionToolNames: [JEV_TOOL_NAME] } : {}
     });
     const agent = piSession.session.agent;
@@ -18992,6 +19847,8 @@ ${context.text}
     const unsubscribers = [...this.listeners].map((listener) => session.agent.subscribe(listener));
     unsubscribers.push(session.agent.subscribe((event) => {
       this.recordSearchToolEvent(event);
+      if (event.type === "message_start" && event.message.role === "user")
+        this.steersReachedModel();
     }));
     return unsubscribers;
   }
@@ -19008,6 +19865,7 @@ ${context.text}
       return;
     this.searchToolCallCount += 1;
     if (this.searchToolCallCount >= this.maxSearchToolCalls) {
+      this.interactive.harnessAbort = true;
       this.activeSession?.abort();
     }
     const details = event.result.details;
@@ -19054,9 +19912,11 @@ ${context.text}
       getSystemPrompt: () => buildSystemPrompt(this.currentSystemPromptConfig({
         modelId: this.boundPiRuntime?.session.model?.id ?? resolved?.model.id
       })),
-      contextTransform: (messages) => this.withMemoryContext(messages),
-      customTools: this.tools.filter((tool) => !PI_BUILTIN_TOOL_NAMES.includes(tool.name)),
-      onQuery: (query, pi) => this.runInteractivePiQuery(query, pi),
+      contextTransform: async (messages) => this.withMemoryContext(frameSteers(messages, this.interactive.steerTexts)),
+      customTools: this.steerableTools(),
+      onInput: (input, pi) => this.routeInteractiveInput(input, pi),
+      isSearchRunning: () => this.interactive.run !== undefined,
+      onKey: (key) => this.handleInteractiveKey(key),
       ...this.jevExtension !== undefined ? { extensionFactories: [this.jevExtension], extensionToolNames: [JEV_TOOL_NAME] } : {},
       ...this.updateNotice === undefined ? {} : { updateNotice: this.updateNotice }
     });
@@ -19071,18 +19931,154 @@ ${context.text}
       }
     };
   }
+  steerableTools() {
+    return this.tools.filter((tool) => !PI_BUILTIN_TOOL_NAMES.includes(tool.name)).map((tool) => this.searchToolNames.has(tool.name) || tool.name === WEB_SEARCH_TOOL_NAME || tool.name === WEB_FETCH_TOOL_NAME ? this.interruptibleBySteer(tool) : tool);
+  }
+  interruptibleBySteer(tool) {
+    return {
+      ...tool,
+      execute: async (toolCallId, params, signal, onUpdate) => {
+        const steer = this.interactive.steerInterrupt.signal;
+        if (steer.aborted)
+          return skippedBySteer(tool.name);
+        const combined = signal === undefined ? steer : AbortSignal.any([signal, steer]);
+        let onSteer = () => {};
+        const steered = new Promise((resolve) => {
+          onSteer = () => resolve("steered");
+          steer.addEventListener("abort", onSteer, { once: true });
+        });
+        try {
+          const outcome = await Promise.race([tool.execute(toolCallId, params, combined, onUpdate), steered]);
+          return outcome === "steered" ? skippedBySteer(tool.name) : outcome;
+        } catch (error) {
+          if (steer.aborted && signal?.aborted !== true)
+            return skippedBySteer(tool.name);
+          throw error;
+        } finally {
+          steer.removeEventListener("abort", onSteer);
+        }
+      }
+    };
+  }
   deriveAnswer(text) {
     const derived = deriveResultsFromAnswer(text, this.evidenceLedger, { allowLocalFiles: !this.remoteSession });
     this.routingDiagnostics.push(...derived.diagnostics);
     return derived.details;
   }
+  routeInteractiveInput(input, pi) {
+    const state = this.interactive;
+    const followUp = input.streamingBehavior === "followUp" || state.nextSubmitIsFollowUp;
+    state.nextSubmitIsFollowUp = false;
+    if (state.run === undefined) {
+      this.startInteractiveQuery(input.text, pi);
+      return { kind: "handled" };
+    }
+    if (followUp) {
+      state.followUps.push(input.text);
+      return { kind: "handled" };
+    }
+    if (input.streamingBehavior === "steer") {
+      state.steers.push(input.text);
+      state.steerTexts.add(input.text);
+      state.steerInterrupt.abort();
+      return { kind: "steer", text: input.text };
+    }
+    if (!this.steer(input.text, input.images))
+      state.followUps.push(input.text);
+    return { kind: "handled" };
+  }
+  handleInteractiveKey(key) {
+    const state = this.interactive;
+    if (state.run === undefined || this.boundPiRuntime?.session.isStreaming === true)
+      return false;
+    if (key === "followUp") {
+      state.nextSubmitIsFollowUp = true;
+      return false;
+    }
+    state.userAborted = true;
+    state.steerInterrupt.abort();
+    return true;
+  }
+  startInteractiveQuery(query, pi) {
+    const state = this.interactive;
+    const run = (async () => {
+      let next = query;
+      while (next !== undefined) {
+        try {
+          await this.runInteractivePiQuery(next, pi);
+        } catch (error) {
+          pi.sendMessage({
+            customType: "autorag.error",
+            content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+            display: true
+          }, { triggerTurn: false });
+        }
+        next = state.followUps.shift();
+      }
+    })().finally(() => {
+      state.run = undefined;
+    });
+    state.run = run;
+  }
   async runInteractivePiQuery(query, pi) {
     pi.setSessionName(query.slice(0, 80));
-    for await (const _event of this.searchDocumentsStream(query)) {}
+    const state = this.interactive;
+    const session = this.boundPiRuntime?.session;
+    const unsubscribe = session?.subscribe((event) => {
+      if (event.type === "queue_update" && state.queuedSteers.length > 0 && !session.agent.hasQueuedMessages()) {
+        state.queuedSteers.length = 0;
+      }
+      if (event.type === "agent_settled" && event.aborted && !state.harnessAbort)
+        state.userAborted = true;
+    });
+    try {
+      for await (const _event of this.searchDocumentsStream(query)) {}
+    } finally {
+      unsubscribe?.();
+      if (state.queuedSteers.length > 0) {
+        session?.agent.clearSteeringQueue();
+        if (!state.userAborted)
+          state.followUps.unshift(...state.queuedSteers);
+        state.queuedSteers.length = 0;
+      }
+    }
+  }
+  async waitForIdle() {
+    while (this.interactive.run !== undefined)
+      await this.interactive.run;
+  }
+  steer(text, images = []) {
+    const state = this.interactive;
+    if (!this.activeRun || !state.acceptingSteers || state.userAborted || text.trim() === "")
+      return false;
+    state.steers.push(text);
+    state.steerTexts.add(text);
+    state.steerInterrupt.abort();
+    const content = [{ type: "text", text }, ...images];
+    const message = { role: "user", content, timestamp: Date.now() };
+    const agent = this.activeSession?.agent;
+    if (agent === undefined)
+      state.preSessionSteers.push(message);
+    else
+      agent.steer(message);
+    state.queuedSteers.push(text);
+    return true;
   }
   abort() {
+    if (!this.activeRun)
+      return;
+    const state = this.interactive;
+    state.userAborted = true;
+    state.steerInterrupt.abort();
+    this.activeRunAbort?.abort();
     this.activeSession?.abort();
   }
+  steersReachedModel() {
+    const state = this.interactive;
+    state.queuedSteers.length = 0;
+    if (state.steerInterrupt.signal.aborted && !state.userAborted)
+      state.steerInterrupt = new AbortController;
+  }
   startAutoRefresh(intervalMs, options = {}) {
     this.stopAutoRefresh();
     const tick = () => {
@@ -19142,6 +20138,15 @@ ${context.text}
     const publishOnCapture = this.jevJudge === undefined;
     let published = false;
     const planAbort = new AbortController;
+    this.activeRunAbort = planAbort;
+    const steering = this.interactive;
+    steering.steers.length = 0;
+    steering.queuedSteers.length = 0;
+    steering.preSessionSteers.length = 0;
+    steering.harnessAbort = false;
+    steering.userAborted = false;
+    steering.steerInterrupt = new AbortController;
+    steering.acceptingSteers = true;
     const publishPreliminary = (details) => {
       if (planAbort.signal.aborted || published)
         return;
@@ -19177,6 +20182,9 @@ ${context.text}
       session = await this.createSearchSession(resolved, buildSystemPrompt(this.currentSystemPromptConfig({ modelId: resolved.model.id })));
       this.activeSession = session;
       unsubscribers = this.configureSearchSession(session);
+      for (const message of steering.preSessionSteers)
+        session.agent.steer(message);
+      steering.preSessionSteers.length = 0;
       let timeout;
       let timedOutAfterFastAnswer = false;
       try {
@@ -19237,25 +20245,42 @@ Warning: the edited config did not validate, so the previous config was restored
               }
               return;
             }
-            if (plan.route === "direct") {
+            const steered = () => this.interactive.steers.length > 0;
+            const stopped = () => this.interactive.userAborted;
+            if (stopped())
+              return;
+            let directText;
+            if (plan.route === "direct" && !steered()) {
               setThinking(this.fastThinkingLevel);
               await activeSession.prompt(this.buildDirectAnswerPrompt(trimmedQuery));
-              const answer = finalAnswerText(transcript());
-              if (answer !== undefined)
-                captured = this.deriveAnswer(answer);
+              if (stopped())
+                return;
+              directText = finalAnswerText(transcript());
+              if (!steered()) {
+                if (directText !== undefined)
+                  captured = this.deriveAnswer(directText);
+                return;
+              }
+            }
+            const baseline = plan.route === "direct" ? "" : await this.prefetchInitialRetrievalContext(trimmedQuery, plan.queries, options, plan.datasources);
+            if (stopped())
               return;
+            let fastText = directText;
+            let preliminary;
+            if (plan.route !== "direct") {
+              setThinking(this.fastThinkingLevel);
+              await activeSession.prompt(this.buildFastAnswerPrompt(trimmedQuery, options, baseline));
+              if (stopped())
+                return;
+              fastText = finalAnswerText(transcript());
+              preliminary = fastText === undefined ? undefined : this.deriveAnswer(fastText);
             }
-            const baseline = await this.prefetchInitialRetrievalContext(trimmedQuery, plan.queries, options, plan.datasources);
-            setThinking(this.fastThinkingLevel);
-            await activeSession.prompt(this.buildFastAnswerPrompt(trimmedQuery, options, baseline));
-            const fastText = finalAnswerText(transcript());
-            const preliminary = fastText === undefined ? undefined : this.deriveAnswer(fastText);
             if (preliminary !== undefined) {
               emitPreliminary(preliminary);
-              const followUp = await this.shouldFollowUp(trimmedQuery, preliminary);
-              if (planAbort.signal.aborted)
+              const followUp = steered() || await this.shouldFollowUp(trimmedQuery, preliminary);
+              if (planAbort.signal.aborted || stopped())
                 return;
-              if (!followUp) {
+              if (!followUp && !steered()) {
                 captured = preliminary;
                 return;
               }
@@ -19263,14 +20288,23 @@ Warning: the edited config did not validate, so the previous config was restored
             }
             setThinking(this.finalThinkingLevel);
             const fastAnswerDelivered = preliminary !== undefined && this.preliminaryCallback !== undefined;
-            await activeSession.prompt(this.buildRefinementPrompt(trimmedQuery, options, fastText, fastAnswerDelivered));
+            await activeSession.prompt(this.buildRefinementPrompt(trimmedQuery, options, fastText, fastAnswerDelivered, this.interactive.steers));
+            while (!stopped() && !planAbort.signal.aborted && this.interactive.queuedSteers.length > 0) {
+              await activeSession.prompt(buildSteerContinuationPrompt(this.interactive.steers));
+            }
+            steering.acceptingSteers = false;
+            if (stopped())
+              return;
             const finalText = finalAnswerText(transcript());
             if (finalText !== undefined)
               captured = this.deriveAnswer(finalText);
-          })(),
+          })().finally(() => {
+            steering.acceptingSteers = false;
+          }),
           new Promise((resolve, reject) => {
             timeout = setTimeout(() => {
               planAbort.abort();
+              this.interactive.harnessAbort = true;
               Promise.resolve(session?.abort());
               if (fastCaptured !== undefined && !this.remoteSession) {
                 timedOutAfterFastAnswer = true;
@@ -19717,12 +20751,13 @@ Warning: the edited config did not validate, so the previous config was restored
     return selection.selected;
   }
   async prefetchInitialRetrievalContext(query, searchQueries, options, datasources = []) {
-    const retrieveOptions = { topK: this.limits.prefetch.minSyncTopK, scope: options.scope };
+    const signal = this.interactive.steerInterrupt.signal;
+    const retrieveOptions = { topK: this.limits.prefetch.minSyncTopK, scope: options.scope, signal };
     const formatSearchQueries = (list) => `Search queries (decomposed from the original question):
 ${list.map((entry, index) => `[${index + 1}] ${entry}`).join(`
 `)}`;
     const perQuery = await Promise.all(searchQueries.map((searchQuery) => Promise.all([
-      this.jikjiClient === undefined ? Promise.resolve(undefined) : this.findJikji(searchQuery, { topK: this.limits.prefetch.jikjiTopK }).catch(() => {
+      this.jikjiClient === undefined ? Promise.resolve(undefined) : this.findJikji(searchQuery, { topK: this.limits.prefetch.jikjiTopK, signal }).catch(() => {
         return;
       }),
       this.minSyncMethod.retrieve(searchQuery, retrieveOptions).catch((error) => {
@@ -19732,7 +20767,8 @@ ${list.map((entry, index) => `[${index + 1}] ${entry}`).join(`
       }),
       Promise.all(datasources.map((datasourceId) => this.searchSingleDatasourceDocuments(datasourceId, searchQuery, {
         topK: this.limits.singleDatasourceTopK,
-        scope: options.scope
+        scope: options.scope,
+        signal
       }).then((outcome) => outcome.results).catch(() => [])))
     ])));
     for (const [index, [jikji, vector, perDatasource]] of perQuery.entries()) {
@@ -19782,7 +20818,7 @@ ${list.map((entry, index) => `[${index + 1}] ${entry}`).join(`
       options.observedSources?.add(result.source);
     for (const result of datasourceResults)
       options.observedSources?.add(result.source);
-    const reranked = await this.rerankPrefetchPool(query, jikjiPaths, minSyncResults, datasourceResults);
+    const reranked = await this.rerankPrefetchPool(query, jikjiPaths, minSyncResults, datasourceResults, signal);
     if (reranked !== undefined) {
       const baseline = formatRerankedBaseline(reranked, reranked.map((result) => this.evidenceLedger.registerResult("baseline", result)));
       return searchQueries.length > 1 ? `${formatSearchQueries(searchQueries)}
@@ -19814,7 +20850,7 @@ ${result.content.replace(/\s+/gu, " ")}`).join(`
 
 `);
   }
-  async rerankPrefetchPool(query, answerPaths, minSyncResults, datasourceResults) {
+  async rerankPrefetchPool(query, answerPaths, minSyncResults, datasourceResults, signal) {
     const reranker = this.reranker;
     if (reranker === undefined)
       return;
@@ -19832,7 +20868,7 @@ ${result.content.replace(/\s+/gu, " ")}`).join(`
     if (!reranker.describe().available)
       return;
     try {
-      const reranked = await reranker.rerank(query, candidates, { topN: this.rerankTopN });
+      const reranked = await reranker.rerank(query, candidates, { topN: this.rerankTopN, signal });
       return reranked.length > 0 ? reranked : undefined;
     } catch {
       return;
@@ -19875,7 +20911,7 @@ ${baseline}
     const fetch2 = names.has(WEB_FETCH_TOOL_NAME) ? ` (and ${WEB_FETCH_TOOL_NAME} to read a promising page)` : "";
     return `When local evidence is missing, thin, or possibly outdated — or the question concerns current events, recent releases, prices, or other public facts — use ${WEB_SEARCH_TOOL_NAME}${fetch2} to confirm or correct claims and fill gaps; use URLs as result sources for web-derived evidence. `;
   }
-  buildRefinementPrompt(query, options, fastAnswer, fastAnswerDelivered) {
+  buildRefinementPrompt(query, options, fastAnswer, fastAnswerDelivered, steers = []) {
     const limit = typeof options.topK === "number" ? ` Cite at most ${options.topK} sources.` : "";
     const scope = options.scope ? ` Restrict search to virtual path scope ${options.scope}.` : "";
     const firstAnswer = formatFirstAnswerContext(fastAnswer, fastAnswerDelivered);
@@ -19898,7 +20934,7 @@ ${baseline}
 
 ` + `${firstAnswer}
 
-` + `Now verify it rigorously. ${this.discoveryHint((tools) => `Actively use ${tools} when discovering or exploring local files and folders. `)}Check important claims against source files with bash when needed, correct anything wrong or unsupported, fill gaps with retrieval tools, and resolve conflicts and freshness. ${this.webFallbackHint()}
+` + formatSteerContext(steers) + `Now verify it rigorously. ${this.discoveryHint((tools) => `Actively use ${tools} when discovering or exploring local files and folders. `)}Check important claims against source files with bash when needed, correct anything wrong or unsupported, fill gaps with retrieval tools, and resolve conflicts and freshness. ${this.webFallbackHint()}
 
 ` + `${answerRules}
 
@@ -20301,7 +21337,8 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
     const sourceRoots = planJikjiSourceRoots(this.searchPaths);
     const findOpts = {
       topK: opts?.topK,
-      first: opts?.first
+      first: opts?.first,
+      ...opts?.signal === undefined ? {} : { signal: opts.signal }
     };
     const diagnostics = [];
     const okPacks = [];
@@ -20452,13 +21489,18 @@ ${initialRetrievalContext ?? "Pending; continue only with a brief progress state
     return { results, diagnostics };
   }
   async searchAllDocuments(query, options = {}) {
-    return this.retrieveWithDiagnostics(query, { topK: options.topK, scope: options.scope });
+    return this.retrieveWithDiagnostics(query, {
+      topK: options.topK,
+      scope: options.scope,
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    });
   }
   async searchSingleDatasourceDocuments(datasourceId, query, options = {}) {
     const retrievalOptions = {
       ...this.activeRetrievalOptions,
       topK: options.topK,
-      scope: options.scope
+      scope: options.scope,
+      ...options.signal === undefined ? {} : { signal: options.signal }
     };
     const methods = this.methodRegistry.list().filter((method) => {
       const descriptor = method.describe();
@@ -20561,6 +21603,49 @@ ${result.content.replace(/\s+/gu, " ")}`);
 ${lines.join(`
 `)}`;
 }
+function skippedBySteer(toolName) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Skipped due to the user's steering message. ${toolName} was stopped before it returned; do not count it as completed work. Apply the steering message, then retry the search if it is still needed.`
+      }
+    ],
+    details: { method: toolName, skipped: "steer" }
+  };
+}
+function buildSteerMessage(text) {
+  return `The user interrupted the running search with this correction:
+
+${text}
+
+` + `Treat it as direction for the search in progress, not as a new question: adjust which sources, queries, or claims you pursue, then continue. ` + `When finished, reply with the final answer to the original question, updated for this correction, and no tool call.`;
+}
+function frameSteers(messages, steerTexts) {
+  if (steerTexts.size === 0)
+    return messages;
+  return messages.map((message) => {
+    if (message.role !== "user" || typeof message.content === "string")
+      return message;
+    const [first, ...rest] = message.content;
+    if (first?.type !== "text" || !steerTexts.has(first.text))
+      return message;
+    return { ...message, content: [{ ...first, text: buildSteerMessage(first.text) }, ...rest] };
+  });
+}
+function formatSteerContext(steers) {
+  if (steers.length === 0)
+    return "";
+  return `While the search ran, the user corrected it:
+${steers.map((steer) => `- ${steer}`).join(`
+`)}
+` + `The first answer predates these corrections; follow them over it.
+
+`;
+}
+function buildSteerContinuationPrompt(steers) {
+  return `${formatSteerContext(steers)}Apply the latest correction: search or verify further if it needs that, ` + `then reply with the complete final answer to the original question and no tool call.`;
+}
 function formatFirstAnswerContext(fastAnswer, delivered) {
   if (fastAnswer === undefined) {
     return "(the fast phase produced no answer — write the complete answer)";
@@ -21023,23 +22108,175 @@ ${this.description}`
   }
 }
 
-// src/datasource/skills/clawgallery/client.ts
-import { spawn as spawn9 } from "node:child_process";
-import { existsSync as existsSync23 } from "node:fs";
-
-class ClawGalleryClient {
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  async bootstrap(signal) {
-    if (this.options.path !== undefined && !existsSync23(this.options.path)) {
-      return {
-        ok: false,
-        reason: "nonzero-exit",
-        stdout: "",
-        stderr: "configured ClawGallery folder does not exist",
-        code: null
+// src/datasource/connector.ts
+import { createHash as createHash12 } from "node:crypto";
+function connectorFailureToDiagnosticCode(reason) {
+  switch (reason) {
+    case "auth":
+      return "datasource-auth-error";
+    case "permission":
+      return "datasource-permission-denied";
+    case "rate-limited":
+      return "datasource-rate-limited";
+    case "unavailable":
+    case "not-configured":
+      return "datasource-unavailable";
+    case "empty":
+      return "datasource-empty";
+    case "api-error":
+    case "invalid-data":
+      return "datasource-index-failed";
+  }
+}
+function boundDiagnosticText(value) {
+  const trimmed = value.trim();
+  return trimmed.length > 500 ? `${trimmed.slice(0, 500)}...` : trimmed;
+}
+function sanitizeIdSegment(value) {
+  const normalized = value.replace(/[^\p{L}\p{N}._-]+/gu, "-");
+  let start = 0;
+  while (start < normalized.length && (normalized[start] === "-" || normalized[start] === "."))
+    start += 1;
+  let end = normalized.length;
+  while (end > start && (normalized[end - 1] === "-" || normalized[end - 1] === "."))
+    end -= 1;
+  const cleaned = normalized.slice(start, end);
+  if (cleaned === value && cleaned.length > 0 && cleaned.length <= 80)
+    return cleaned;
+  const hash = createHash12("sha256").update(value).digest("hex").slice(0, 8);
+  const stem = cleaned.slice(0, 60);
+  return stem.length > 0 ? `${stem}-${hash}` : hash;
+}
+var init_connector = () => {};
+
+// src/datasource/sidecar/config.ts
+import { readFileSync as readFileSync19 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname17, isAbsolute as isAbsolute8, join as join30, resolve as resolve14, sep as sep7 } from "node:path";
+import { parse as parseToml2 } from "smol-toml";
+function resolveSidecarOptions(input) {
+  const { connector, workspaceRoot } = input;
+  const setting = connector?.sidecar;
+  if (setting === false || workspaceRoot === undefined)
+    return;
+  const object = typeof setting === "object" && setting !== null && !Array.isArray(setting) ? setting : {};
+  if (object.enabled === false)
+    return;
+  const configured = [object.crawlerDbPath, connector?.databasePath].find((value) => typeof value === "string" && value.length > 0);
+  const crawlerDbPath = expandHome(configured ?? archivePathFromCrawlerConfig(input) ?? input.defaultCrawlerDb);
+  const workspaceId = typeof connector?.workspace === "string" && connector.workspace.length > 0 ? connector.workspace : undefined;
+  return {
+    descriptor: input.descriptor,
+    crawlerDbPath,
+    sidecarDbPath: join30(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(input.registrationName), sanitizeIdSegment(input.instanceId), "sidecar.sqlite"),
+    ...workspaceId === undefined ? {} : { workspaceId },
+    ...object.semantic === false ? {} : { embedder: createGatewayEmbedder() }
+  };
+}
+function archivePathFromCrawlerConfig(input) {
+  const configPath = input.connector?.configPath;
+  if (input.descriptor.archivePathInConfig !== true || typeof configPath !== "string" || configPath.length === 0) {
+    return;
+  }
+  const file = expandHome(configPath);
+  try {
+    const dbPath = parseToml2(readFileSync19(file, "utf8")).db_path;
+    if (typeof dbPath !== "string" || dbPath.length === 0)
+      return;
+    const expanded = expandHome(dbPath);
+    return isAbsolute8(expanded) ? expanded : resolve14(dirname17(file), expanded);
+  } catch {
+    return;
+  }
+}
+function expandHome(path) {
+  if (path === "~")
+    return homedir3();
+  const prefixed = path.startsWith("~/") || sep7 === "\\" && path.startsWith("~\\");
+  return prefixed ? join30(homedir3(), path.slice(2)) : path;
+}
+var init_config2 = __esm(() => {
+  init_connector();
+});
+
+// src/datasource/sidecar/descriptors.ts
+function chatCrawler(id) {
+  return {
+    id,
+    keyExpression: "m.event_id",
+    chunkId: (key) => key,
+    fromClause: "messages m",
+    liveWhere: "(m.deleted_at is null or m.deleted_at = 0)",
+    textExpression: "coalesce(m.text, '')",
+    titleExpression: "m.chat_name",
+    epochSecondsExpression: "m.ts",
+    fts: { table: "messages_fts", joinOn: "messages_fts.rowid = m.rowid" },
+    metadata: [
+      { sql: "m.chat_jid", key: "chatId" },
+      { sql: "m.chat_name", key: "chatName" },
+      { sql: "m.sender_name", key: "senderName" },
+      { sql: "m.ts", key: "timestamp" }
+    ],
+    channelIdExpression: "m.chat_jid",
+    channelNameExpression: "m.chat_name",
+    hierarchy: (metadata) => ["chats", str(metadata.chatName) ?? str(metadata.chatId) ?? "unknown"]
+  };
+}
+var str = (value) => typeof value === "string" && value.length > 0 ? value : undefined, slack, CRAWLER_DESCRIPTORS;
+var init_descriptors = __esm(() => {
+  slack = {
+    id: "slack",
+    archivePathInConfig: true,
+    keyExpression: "m.channel_id || '|' || m.ts",
+    chunkId: (_key, metadata) => `${metadata.channelId ?? ""}-${(metadata.timestamp ?? "").replaceAll(".", "-")}`,
+    fromClause: "messages m left join channels c on c.id = m.channel_id and c.workspace_id = m.workspace_id " + "left join users u on u.id = m.user_id",
+    liveWhere: "(m.deleted_ts is null or m.deleted_ts = '')",
+    scopeExpression: "m.workspace_id",
+    textExpression: "coalesce(nullif(m.normalized_text, ''), m.text)",
+    titleExpression: "c.name",
+    epochSecondsExpression: "cast(m.ts as real)",
+    fts: { table: "message_fts", joinOn: "message_fts.message_key = m.channel_id || '|' || m.ts" },
+    metadata: [
+      { sql: "m.channel_id", key: "channelId" },
+      { sql: "c.name", key: "channelName" },
+      { sql: "m.workspace_id", key: "workspaceId" },
+      { sql: "m.user_id", key: "userId" },
+      { sql: "coalesce(nullif(u.real_name, ''), u.name)", key: "senderName" },
+      { sql: "m.ts", key: "timestamp" }
+    ],
+    channelIdExpression: "m.channel_id",
+    channelNameExpression: "c.name",
+    hierarchy: (metadata) => [
+      "workspaces",
+      str(metadata.workspaceId) ?? "unknown",
+      "channels",
+      str(metadata.channelName) ?? str(metadata.channelId) ?? "unknown"
+    ]
+  };
+  CRAWLER_DESCRIPTORS = {
+    slack,
+    telegram: chatCrawler("telegram"),
+    whatsapp: chatCrawler("whatsapp")
+  };
+});
+
+// src/datasource/skills/clawgallery/client.ts
+import { spawn as spawn9 } from "node:child_process";
+import { existsSync as existsSync23 } from "node:fs";
+
+class ClawGalleryClient {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async bootstrap(signal) {
+    if (this.options.path !== undefined && !existsSync23(this.options.path)) {
+      return {
+        ok: false,
+        reason: "nonzero-exit",
+        stdout: "",
+        stderr: "configured ClawGallery folder does not exist",
+        code: null
       };
     }
     const args = ["bootstrap"];
@@ -21138,7 +22375,7 @@ function spawnCli(binary, args, env, options, signal) {
     const timeout = setTimeout(() => {
       reason = "timeout";
       terminate2(child);
-    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS6);
+    }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS7);
     const abort = () => {
       reason = "aborted";
       terminate2(child);
@@ -21244,16 +22481,16 @@ function failure2(result, reason) {
     ok: false,
     reason: reason ?? result.reason ?? "nonzero-exit",
     stdout: result.stdout,
-    stderr: boundDiagnosticText(result.stderr),
+    stderr: boundDiagnosticText2(result.stderr),
     code: result.code
   };
 }
-function boundDiagnosticText(value) {
+function boundDiagnosticText2(value) {
   if (value.length === 0)
     return "";
   return value.trim().slice(0, 4000);
 }
-var DEFAULT_BINARY2 = "clawgallery", DEFAULT_TIMEOUT_MS6 = 60000, DEFAULT_MAX_BUFFER_BYTES2, SAFE_ENV;
+var DEFAULT_BINARY2 = "clawgallery", DEFAULT_TIMEOUT_MS7 = 60000, DEFAULT_MAX_BUFFER_BYTES2, SAFE_ENV;
 var init_client5 = __esm(() => {
   init_portable_spawn();
   DEFAULT_MAX_BUFFER_BYTES2 = 4 * 1024 * 1024;
@@ -21547,7 +22784,7 @@ function statusToReason(status) {
 }
 async function requestText(url, options) {
   const fetchImpl = options.fetchImpl ?? globalThis.fetch;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS7;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS8;
   let response;
   try {
     response = await fetchImpl(url, {
@@ -21611,13 +22848,13 @@ function resolveToken(token, tokenEnv) {
   }
   return;
 }
-var DEFAULT_TIMEOUT_MS7 = 15000;
+var DEFAULT_TIMEOUT_MS8 = 15000;
 
 // src/datasource/skills/cloud-drive/rclone-connector.ts
 import { spawn as spawn10 } from "node:child_process";
-import { mkdirSync as mkdirSync18, readFileSync as readFileSync19, renameSync as renameSync10, rmSync as rmSync9, writeFileSync as writeFileSync17 } from "node:fs";
+import { mkdirSync as mkdirSync18, readFileSync as readFileSync20, renameSync as renameSync10, rmSync as rmSync9, writeFileSync as writeFileSync17 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import { dirname as dirname17, join as join30, normalize as normalize4 } from "node:path";
+import { dirname as dirname18, join as join31, normalize as normalize4 } from "node:path";
 
 class RcloneConnector {
   options;
@@ -21633,7 +22870,7 @@ class RcloneConnector {
     if (remote === undefined || remote.length === 0) {
       return { ok: false, reason: "not-configured", message: "rclone remote not configured" };
     }
-    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS8;
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS9;
     const exportFormats = this.options.exportFormats ?? DEFAULT_EXPORT_FORMATS;
     let listResult;
     try {
@@ -21704,7 +22941,7 @@ class RcloneConnector {
         return;
       const destination = mirrorFilePath(paths.mirrorRoot, entry.path);
       const temp = `${destination}.autorag-tmp`;
-      mkdirSync18(dirname17(temp), { recursive: true });
+      mkdirSync18(dirname18(temp), { recursive: true });
       let copied;
       try {
         copied = await this.runner(copyArgs(remote, entry.path, temp, exportFormats, this.options.concurrency, this.options.bandwidthLimit), timeoutMs);
@@ -21809,12 +23046,12 @@ function sameEntry(previous, current) {
   return previous?.path === current.path && previous.size === current.size && previous.modTime === current.modTime && previous.remoteId === current.remoteId && JSON.stringify(previous.hashes) === JSON.stringify(current.hashes);
 }
 function mirrorPaths(workspaceRoot, skillName, instanceId) {
-  const base = join30(workspaceRoot, ".autorag", "datasources", skillName, instanceId);
-  return { mirrorRoot: join30(base, "mirror"), manifestPath: join30(base, "manifest.json") };
+  const base = join31(workspaceRoot, ".autorag", "datasources", skillName, instanceId);
+  return { mirrorRoot: join31(base, "mirror"), manifestPath: join31(base, "manifest.json") };
 }
 function mirrorFilePath(root, path) {
   const safe = normalize4(path).replace(/^(\.\.(?:[/\\]|$))+|^[/\\]+/gu, "");
-  return join30(root, safe);
+  return join31(root, safe);
 }
 function remoteTarget(remote, path) {
   return remote.endsWith(":") || remote.endsWith("/") ? `${remote}${path}` : `${remote}/${path}`;
@@ -21833,14 +23070,14 @@ function copyArgs(remote, path, destination, exportFormats, concurrency, bandwid
 }
 function loadManifest2(path) {
   try {
-    const parsed = JSON.parse(readFileSync19(path, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path, "utf8"));
     return parsed.version === 1 && Array.isArray(parsed.entries) ? parsed : undefined;
   } catch {
     return;
   }
 }
 function saveManifest(path, manifest) {
-  mkdirSync18(dirname17(path), { recursive: true });
+  mkdirSync18(dirname18(path), { recursive: true });
   const temp = `${path}.autorag-tmp`;
   writeFileSync17(temp, `${JSON.stringify(manifest)}
 `, "utf8");
@@ -21942,7 +23179,7 @@ function runBinary(binary, args, timeoutMs, env, cwd) {
     });
   });
 }
-var DEFAULT_BINARY3 = "rclone", DEFAULT_EXTENSIONS, DEFAULT_EXPORT_FORMATS = "txt,csv", DEFAULT_MAX_DOCUMENTS = 200, DEFAULT_MAX_BYTES_PER_FILE, DEFAULT_TIMEOUT_MS8 = 60000, MAX_CONTENT_CHARS2 = 1e5;
+var DEFAULT_BINARY3 = "rclone", DEFAULT_EXTENSIONS, DEFAULT_EXPORT_FORMATS = "txt,csv", DEFAULT_MAX_DOCUMENTS = 200, DEFAULT_MAX_BYTES_PER_FILE, DEFAULT_TIMEOUT_MS9 = 60000, MAX_CONTENT_CHARS2 = 1e5;
 var init_rclone_connector = __esm(() => {
   init_defaults();
   init_portable_spawn();
@@ -21950,52 +23187,11 @@ var init_rclone_connector = __esm(() => {
   DEFAULT_MAX_BYTES_PER_FILE = 2 * 1024 * 1024;
 });
 
-// src/datasource/connector.ts
-import { createHash as createHash12 } from "node:crypto";
-function connectorFailureToDiagnosticCode(reason) {
-  switch (reason) {
-    case "auth":
-      return "datasource-auth-error";
-    case "permission":
-      return "datasource-permission-denied";
-    case "rate-limited":
-      return "datasource-rate-limited";
-    case "unavailable":
-    case "not-configured":
-      return "datasource-unavailable";
-    case "empty":
-      return "datasource-empty";
-    case "api-error":
-    case "invalid-data":
-      return "datasource-index-failed";
-  }
-}
-function boundDiagnosticText2(value) {
-  const trimmed = value.trim();
-  return trimmed.length > 500 ? `${trimmed.slice(0, 500)}...` : trimmed;
-}
-function sanitizeIdSegment(value) {
-  const normalized = value.replace(/[^\p{L}\p{N}._-]+/gu, "-");
-  let start = 0;
-  while (start < normalized.length && (normalized[start] === "-" || normalized[start] === "."))
-    start += 1;
-  let end = normalized.length;
-  while (end > start && (normalized[end - 1] === "-" || normalized[end - 1] === "."))
-    end -= 1;
-  const cleaned = normalized.slice(start, end);
-  if (cleaned === value && cleaned.length > 0 && cleaned.length <= 80)
-    return cleaned;
-  const hash = createHash12("sha256").update(value).digest("hex").slice(0, 8);
-  const stem = cleaned.slice(0, 60);
-  return stem.length > 0 ? `${stem}-${hash}` : hash;
-}
-var init_connector = () => {};
-
 // src/datasource/chunk-store.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync19, readFileSync as readFileSync20, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname18, join as join31 } from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync19, readFileSync as readFileSync21, writeFileSync as writeFileSync18 } from "node:fs";
+import { dirname as dirname19, join as join32 } from "node:path";
 function datasourceChunkStorePath(workspaceRoot, skillName, instanceId) {
-  return join31(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId), "chunks.json");
+  return join32(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId), "chunks.json");
 }
 
 class DatasourceChunkStore {
@@ -22034,7 +23230,7 @@ class DatasourceChunkStore {
     try {
       if (!existsSync24(this.storePath))
         return false;
-      const parsed = JSON.parse(readFileSync20(this.storePath, "utf8"));
+      const parsed = JSON.parse(readFileSync21(this.storePath, "utf8"));
       if (parsed.version !== STORE_VERSION || !Array.isArray(parsed.chunks))
         return false;
       this.chunkList = parsed.chunks.filter((chunk) => typeof chunk?.chunkId === "string" && typeof chunk?.content === "string");
@@ -22080,7 +23276,7 @@ class DatasourceChunkStore {
     if (this.storePath === undefined)
       return;
     try {
-      mkdirSync19(dirname18(this.storePath), { recursive: true });
+      mkdirSync19(dirname19(this.storePath), { recursive: true });
       const payload = {
         version: STORE_VERSION,
         skill: this.skillName,
@@ -22222,7 +23418,7 @@ class ConnectorDatasourceSkill {
     }
     if (!fetched.ok) {
       const code = connectorFailureToDiagnosticCode(fetched.reason);
-      const message = boundDiagnosticText2(fetched.message ?? fetched.reason);
+      const message = boundDiagnosticText(fetched.message ?? fetched.reason);
       return this.fail(code, `${fetched.reason}: ${message}`);
     }
     const documents = this.applyDedupeWindow(fetched.documents);
@@ -22234,7 +23430,7 @@ class ConnectorDatasourceSkill {
     const diagnostics = (fetched.warnings ?? []).map((warning) => ({
       code: "datasource-index-failed",
       severity: "warning",
-      message: boundDiagnosticText2(warning),
+      message: boundDiagnosticText(warning),
       instanceId: this.instanceId,
       source: this.definition.skillName
     }));
@@ -22351,7 +23547,7 @@ class ConnectorDatasourceSkill {
     return out;
   }
   fail(code, message) {
-    const sanitized = boundDiagnosticText2(message);
+    const sanitized = boundDiagnosticText(message);
     this.lastError = sanitized;
     const diagnostic = {
       code,
@@ -22543,8 +23739,8 @@ var init_types4 = __esm(() => {
 
 // src/datasource/skills/discrawl/client.ts
 import { spawn as spawn12 } from "node:child_process";
-import { mkdirSync as mkdirSync20, readFileSync as readFileSync21, writeFileSync as writeFileSync19 } from "node:fs";
-import { dirname as dirname19 } from "node:path";
+import { mkdirSync as mkdirSync20, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "node:fs";
+import { dirname as dirname20 } from "node:path";
 
 class DiscrawlClient {
   options;
@@ -22560,7 +23756,7 @@ class DiscrawlClient {
     const path = `${workspace}/.autorag/datasources/discrawl/config.toml`;
     let existing = "";
     try {
-      existing = readFileSync21(path, "utf8");
+      existing = readFileSync22(path, "utf8");
     } catch {}
     const managed = existing.startsWith(`# AutoRAG managed discrawl embeddings v1
 `);
@@ -22568,7 +23764,7 @@ class DiscrawlClient {
       return { configured: false, rebuildRequired: false };
     const previous = managed ? parseManagedEmbedding(existing) : undefined;
     const config = managedDiscrawlConfig({ ...runtime, baseUrl: nativeGatewayBaseUrl(runtime.baseUrl) });
-    mkdirSync20(dirname19(path), { recursive: true });
+    mkdirSync20(dirname20(path), { recursive: true });
     if (existing !== config)
       writeFileSync19(path, config, "utf8");
     return {
@@ -23593,8 +24789,8 @@ var init_github = __esm(() => {
 
 // src/datasource/skills/github-gist/connector.ts
 import { execFile as execFile2 } from "node:child_process";
-import { existsSync as existsSync25, mkdirSync as mkdirSync21, readFileSync as readFileSync22, writeFileSync as writeFileSync20 } from "node:fs";
-import { dirname as dirname20 } from "node:path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync21, readFileSync as readFileSync23, writeFileSync as writeFileSync20 } from "node:fs";
+import { dirname as dirname21 } from "node:path";
 async function defaultGhTokenRunner() {
   return new Promise((resolve) => {
     execFile2("gh", ["auth", "token"], { timeout: GH_TOKEN_TIMEOUT_MS }, (error, stdout) => {
@@ -23716,7 +24912,7 @@ class GitHubGistConnector {
     if (statePath === undefined || !existsSync25(statePath))
       return { version: STATE_VERSION, gists: {} };
     try {
-      const parsed = JSON.parse(readFileSync22(statePath, "utf8"));
+      const parsed = JSON.parse(readFileSync23(statePath, "utf8"));
       if (parsed.version !== STATE_VERSION || typeof parsed.gists !== "object" || parsed.gists === null) {
         return { version: STATE_VERSION, gists: {} };
       }
@@ -23730,7 +24926,7 @@ class GitHubGistConnector {
     if (statePath === undefined)
       return;
     try {
-      mkdirSync21(dirname20(statePath), { recursive: true });
+      mkdirSync21(dirname21(statePath), { recursive: true });
       writeFileSync20(statePath, `${JSON.stringify(state)}
 `, "utf8");
     } catch {}
@@ -23776,8 +24972,8 @@ var init_connector3 = () => {};
 
 // src/datasource/skills/github-gist/semantic.ts
 import { createHash as createHash13 } from "node:crypto";
-import { existsSync as existsSync26, mkdirSync as mkdirSync22, readFileSync as readFileSync23, writeFileSync as writeFileSync21 } from "node:fs";
-import { dirname as dirname21 } from "node:path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync22, readFileSync as readFileSync24, writeFileSync as writeFileSync21 } from "node:fs";
+import { dirname as dirname22 } from "node:path";
 function contentHash(chunk) {
   return createHash13("sha256").update(`${chunk.title ?? ""}
 ${chunk.content}`).digest("hex");
@@ -23870,7 +25066,7 @@ ${chunk.content}`));
     if (this.statePath === undefined || !existsSync26(this.statePath))
       return;
     try {
-      const parsed = JSON.parse(readFileSync23(this.statePath, "utf8"));
+      const parsed = JSON.parse(readFileSync24(this.statePath, "utf8"));
       if (parsed.version !== VECTORS_VERSION || typeof parsed.entries !== "object" || parsed.entries === null)
         return;
       if (typeof parsed.identity?.dimension !== "number")
@@ -23885,7 +25081,7 @@ ${chunk.content}`));
     if (this.identity === undefined)
       return;
     try {
-      mkdirSync22(dirname21(this.statePath), { recursive: true });
+      mkdirSync22(dirname22(this.statePath), { recursive: true });
       const payload = {
         version: VECTORS_VERSION,
         identity: this.identity,
@@ -23968,9 +25164,9 @@ var init_semantic = __esm(() => {
 });
 
 // src/datasource/skills/github-gist/skill.ts
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 function gistDatasourceDir(workspaceRoot, skillName, instanceId) {
-  return join32(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId));
+  return join33(workspaceRoot, ".autorag", "datasources", sanitizeIdSegment(skillName), sanitizeIdSegment(instanceId));
 }
 var GITHUB_GIST_SKILL_DEFINITION, DEFAULT_INSTANCE_ID3 = "default", GitHubGistSkill;
 var init_skill5 = __esm(() => {
@@ -23998,7 +25194,7 @@ var init_skill5 = __esm(() => {
     constructor(options = {}) {
       const { connector, connectorOptions, semantic, ...rest } = options;
       const instanceId = options.instanceId ?? DEFAULT_INSTANCE_ID3;
-      const statePath = connectorOptions?.statePath ?? (options.workspaceRoot === undefined ? undefined : join32(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "state.json"));
+      const statePath = connectorOptions?.statePath ?? (options.workspaceRoot === undefined ? undefined : join33(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "state.json"));
       super(GITHUB_GIST_SKILL_DEFINITION, {
         ...rest,
         connector: connector ?? new GitHubGistConnector({
@@ -24008,7 +25204,7 @@ var init_skill5 = __esm(() => {
       });
       if (semantic?.enabled !== false) {
         this.semanticIndex = new GistSemanticIndex({
-          statePath: semantic?.statePath ?? (options.workspaceRoot === undefined ? undefined : join32(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "vectors.json"))
+          statePath: semantic?.statePath ?? (options.workspaceRoot === undefined ? undefined : join33(gistDatasourceDir(options.workspaceRoot, GITHUB_GIST_SKILL_DEFINITION.skillName, instanceId), "vectors.json"))
         });
         this.semanticEmbedder = semantic?.embedder ?? createGatewayEmbedder(semantic?.embedderOptions ?? {});
         this.semanticMethod = new GitHubGistSemanticMethod({
@@ -24036,7 +25232,7 @@ var init_skill5 = __esm(() => {
           {
             code: "datasource-index-failed",
             severity: "warning",
-            message: boundDiagnosticText2(`semantic-unavailable: ${sync.message}`),
+            message: boundDiagnosticText(`semantic-unavailable: ${sync.message}`),
             instanceId: this.instanceId,
             source: this.describe().name
           }
@@ -24731,7 +25927,7 @@ var init_types5 = __esm(() => {
 // src/datasource/skills/lazykatok/client.ts
 import { spawn as spawn14 } from "node:child_process";
 import { existsSync as existsSync27 } from "node:fs";
-import { delimiter as delimiter4, join as join33 } from "node:path";
+import { delimiter as delimiter4, join as join34 } from "node:path";
 
 class LazykatokClient {
   options;
@@ -24919,7 +26115,7 @@ function lookupInPath2(executable, env) {
   for (const dir of pathEnv.split(delimiter4)) {
     if (dir.length === 0)
       continue;
-    const candidate = join33(dir, executable);
+    const candidate = join34(dir, executable);
     if (existsSync27(candidate))
       return candidate;
   }
@@ -25409,7 +26605,7 @@ var init_lazykatok = __esm(() => {
 
 // src/datasource/skills/mail-export/connector.ts
 import { readdir as readdir3, readFile as readFile5, stat as stat6 } from "node:fs/promises";
-import { basename as basename12, dirname as dirname22, extname as extname7, join as join34 } from "node:path";
+import { basename as basename12, dirname as dirname23, extname as extname7, join as join35 } from "node:path";
 import { simpleParser as simpleParser2 } from "mailparser";
 
 class MailExportConnector {
@@ -25435,7 +26631,7 @@ class MailExportConnector {
               continue;
             const extension = extname7(entry.name).toLowerCase();
             if (extension === ".eml" || extension === ".mbox") {
-              files.push(join34(entry.parentPath, entry.name));
+              files.push(join35(entry.parentPath, entry.name));
             }
           }
         } else if (info.isFile()) {
@@ -25470,7 +26666,7 @@ class MailExportConnector {
         continue;
       }
       const stem = basename12(file, extname7(file));
-      const mailboxDir = basename12(dirname22(file));
+      const mailboxDir = basename12(dirname23(file));
       const hierarchy = ["mailboxes", mailboxDir, stem];
       const extension = extname7(file).toLowerCase();
       const rawMessages = extension === ".mbox" ? splitMbox(bytes.toString("utf8")) : [bytes.toString("utf8")];
@@ -25591,7 +26787,7 @@ function ensurePrivateMailcrawlDataDir(path) {
   if (process.platform !== "win32")
     chmodSync(path, 448);
 }
-var init_config2 = () => {};
+var init_config3 = () => {};
 
 // src/datasource/skills/mailcrawl/client.ts
 import { spawn as spawn15 } from "node:child_process";
@@ -25917,7 +27113,7 @@ function truncateUtf8(value, maxBytes) {
 var DEFAULT_BINARY4 = "mailcrawl", DEFAULT_SEARCH_TIMEOUT_MS3 = 60000, DEFAULT_INDEX_TIMEOUT_MS3 = 1800000, DEFAULT_MAX_BUFFER_BYTES4 = 1048576, LOOPBACK_HOSTS2, SAFE_ENV_KEYS2, SAFE_MAILCRAWL_ENV_KEYS, REMOTE_EMBEDDING_ENV_KEYS;
 var init_client9 = __esm(() => {
   init_portable_spawn();
-  init_config2();
+  init_config3();
   LOOPBACK_HOSTS2 = new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
   SAFE_ENV_KEYS2 = new Set(["HOME", "LANG", "LC_ALL", "PATH", "TMPDIR", "TMP", "TEMP", "NO_COLOR"]);
   SAFE_MAILCRAWL_ENV_KEYS = new Set([
@@ -26164,7 +27360,7 @@ var TAGS;
 var init_skill9 = __esm(() => {
   init_scope2();
   init_client9();
-  init_config2();
+  init_config3();
   init_methods4();
   TAGS = ["mailcrawl", "email", "pii"];
 });
@@ -26176,6 +27372,504 @@ var init_mailcrawl = __esm(() => {
   init_skill9();
 });
 
+// src/datasource/sidecar/fusion.ts
+function encodeVector(vector) {
+  const floats = Float32Array.from(vector);
+  return new Uint8Array(floats.buffer, floats.byteOffset, floats.byteLength);
+}
+function decodeVector(blob) {
+  if (blob.byteLength % Float32Array.BYTES_PER_ELEMENT !== 0)
+    return;
+  return new Float32Array(new Uint8Array(blob).buffer);
+}
+function cosine3(a, b) {
+  if (a.length === 0 || a.length !== b.length)
+    return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let index = 0;index < a.length; index += 1) {
+    const x = a[index] ?? 0;
+    const y = b[index] ?? 0;
+    dot += x * y;
+    normA += x * x;
+    normB += y * y;
+  }
+  if (normA === 0 || normB === 0)
+    return 0;
+  return dot / Math.sqrt(normA * normB);
+}
+function topKByCosine(query, rows, k) {
+  if (k <= 0)
+    return [];
+  const scored = [];
+  for (const row of rows) {
+    const score = cosine3(query, row.vector);
+    if (score > 0)
+      scored.push({ key: row.key, score });
+  }
+  scored.sort((a, b) => b.score - a.score || a.key.localeCompare(b.key));
+  return scored.slice(0, k);
+}
+function reciprocalRankFusion(lists) {
+  const scores = new Map;
+  for (const list of lists) {
+    const seen = new Set;
+    for (const [index, key] of list.entries()) {
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      scores.set(key, (scores.get(key) ?? 0) + 1 / (RRF_K2 + index + 1));
+    }
+  }
+  return [...scores.entries()].map(([key, score]) => ({ key, score })).sort((a, b) => b.score - a.score);
+}
+var RRF_K2 = 60;
+
+// src/datasource/sidecar/index.ts
+import { createHash as createHash14 } from "node:crypto";
+import { mkdirSync as mkdirSync24, statSync as statSync3 } from "node:fs";
+import { dirname as dirname24 } from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { pathToFileURL } from "node:url";
+
+class CrawlerSidecar {
+  descriptor;
+  options;
+  select;
+  where;
+  opened;
+  attached;
+  lastSemantic;
+  constructor(options) {
+    this.options = options;
+    const { descriptor } = options;
+    this.descriptor = descriptor;
+    const metadataColumns = descriptor.metadata.map((column, index) => `${column.sql} as m${index}`);
+    this.select = [
+      `${descriptor.keyExpression} as k`,
+      `${descriptor.textExpression} as content`,
+      `${descriptor.titleExpression ?? "null"} as title`,
+      `${descriptor.epochSecondsExpression ?? "null"} as epoch`,
+      ...metadataColumns
+    ].join(", ");
+    const scope = descriptor.scopeExpression !== undefined && options.workspaceId !== undefined;
+    const allowlist = [
+      ...(options.channelIds?.length ?? 0) > 0 ? [`${descriptor.channelIdExpression} in (${options.channelIds?.map(() => "?").join(", ")})`] : [],
+      ...(options.channelNames?.length ?? 0) > 0 ? [`${descriptor.channelNameExpression} in (${options.channelNames?.map(() => "?").join(", ")})`] : []
+    ];
+    this.where = [
+      descriptor.liveWhere,
+      ...scope ? [`${descriptor.scopeExpression} = ?`] : [],
+      ...allowlist.length > 0 ? [`(${allowlist.join(" or ")})`] : []
+    ].join(" and ");
+  }
+  get db() {
+    if (this.opened !== undefined)
+      return this.opened;
+    mkdirSync24(dirname24(this.options.sidecarDbPath), { recursive: true });
+    const db = new DatabaseSync2(this.options.sidecarDbPath);
+    db.exec(`pragma busy_timeout = ${BUSY_TIMEOUT_MS}`);
+    db.exec("pragma journal_mode = wal");
+    db.exec(`
+			create table if not exists sidecar_meta (k text primary key, v text not null);
+			create table if not exists sidecar_vec (message_key text primary key, hash text not null, vec blob not null);
+		`);
+    this.opened = db;
+    return db;
+  }
+  attachCrawler() {
+    let file;
+    try {
+      const { dev, ino } = statSync3(this.options.crawlerDbPath);
+      file = { dev, ino };
+    } catch {
+      this.detachCrawler();
+      return false;
+    }
+    if (this.attached !== undefined) {
+      if (this.attached.dev === file.dev && this.attached.ino === file.ino)
+        return true;
+      this.detachCrawler();
+    }
+    const crawlerUri = `${pathToFileURL(this.options.crawlerDbPath).href}?mode=ro`.replaceAll("'", "''");
+    try {
+      this.db.exec(`attach database '${crawlerUri}' as crawler`);
+    } catch {
+      return false;
+    }
+    const { descriptor } = this.options;
+    try {
+      this.db.prepare(`select ${this.select} from ${descriptor.fromClause} where ${this.where} limit 0`).all(...this.whereParams());
+      this.db.prepare(`select 1 from ${descriptor.fts.table} limit 0`).all();
+    } catch {
+      this.db.exec("detach database crawler");
+      return false;
+    }
+    this.attached = file;
+    this.lastSemantic = undefined;
+    return true;
+  }
+  detachCrawler() {
+    if (this.attached === undefined)
+      return;
+    this.attached = undefined;
+    this.lastSemantic = undefined;
+    try {
+      this.opened?.exec("detach database crawler");
+    } catch {}
+  }
+  get semanticEnabled() {
+    return this.options.embedder !== undefined;
+  }
+  close() {
+    this.opened?.close();
+    this.opened = undefined;
+    this.attached = undefined;
+    this.lastSemantic = undefined;
+  }
+  whereParams() {
+    const { descriptor, workspaceId, channelIds = [], channelNames = [] } = this.options;
+    return [
+      ...descriptor.scopeExpression !== undefined && workspaceId !== undefined ? [workspaceId] : [],
+      ...channelIds,
+      ...channelNames
+    ];
+  }
+  searchLexical(query, topK) {
+    const match = toMatchQuery(query);
+    if (match === undefined || topK <= 0 || !this.attachCrawler())
+      return [];
+    const { descriptor } = this.options;
+    const rows = this.db.prepare(`select ${this.select}, bm25(${descriptor.fts.table}) as rank
+				from ${descriptor.fromClause} join ${descriptor.fts.table} on ${descriptor.fts.joinOn}
+				where ${descriptor.fts.table} match ? and ${this.where}
+				order by rank limit ?`).all(match, ...this.whereParams(), topK);
+    return rows.map((row) => this.toHit(this.toRow(row), -Number(row.rank)));
+  }
+  async searchSemantic(query, topK) {
+    const trimmed = query.trim();
+    if (this.options.embedder === undefined || trimmed.length === 0 || topK <= 0 || !this.attachCrawler())
+      return [];
+    const ranked = await this.rankSemantic(trimmed, topK * POOL_FACTOR);
+    if (ranked.length === 0)
+      return [];
+    const live = this.hydrate(ranked.map((entry) => entry.key));
+    const hits = [];
+    for (const entry of ranked) {
+      const row = live.get(entry.key);
+      if (row !== undefined)
+        hits.push(this.toHit(row, entry.score));
+      if (hits.length >= topK)
+        break;
+    }
+    return hits;
+  }
+  async rankSemantic(query, pool) {
+    const now = Date.now();
+    let cached = this.lastSemantic;
+    if (cached === undefined || cached.query !== query || now - cached.at > SEMANTIC_REUSE_MS) {
+      const embedder = this.options.embedder;
+      if (embedder === undefined)
+        return [];
+      cached = {
+        query,
+        at: now,
+        vector: embedder.embed([query]).then((vectors) => vectors[0], () => {
+          return;
+        }),
+        ranked: undefined
+      };
+      this.lastSemantic = cached;
+    }
+    const vector = await cached.vector;
+    if (vector === undefined) {
+      if (this.lastSemantic === cached)
+        this.lastSemantic = undefined;
+      return [];
+    }
+    if (cached.ranked === undefined || cached.ranked.pool < pool) {
+      const wide = pool * POOL_FACTOR;
+      cached.ranked = { pool: wide, keys: topKByCosine(vector, this.storedVectors(), wide) };
+    }
+    return cached.ranked.keys.slice(0, pool);
+  }
+  async searchHybrid(query, topK) {
+    if (topK <= 0)
+      return [];
+    const pool = topK * POOL_FACTOR;
+    const lexical = this.searchLexical(query, pool);
+    const semantic = await this.searchSemantic(query, pool);
+    if (semantic.length === 0)
+      return lexical.slice(0, topK);
+    const byKey = new Map;
+    for (const hit of [...semantic, ...lexical])
+      byKey.set(hit.key, hit);
+    const fused = [];
+    for (const entry of reciprocalRankFusion([lexical.map((hit) => hit.key), semantic.map((hit) => hit.key)])) {
+      const hit = byKey.get(entry.key);
+      if (hit !== undefined)
+        fused.push({ ...hit, score: entry.score });
+      if (fused.length >= topK)
+        break;
+    }
+    return fused;
+  }
+  async sync() {
+    const { embedder } = this.options;
+    if (embedder === undefined)
+      return { ok: false, message: "no embedder configured" };
+    if (!this.attachCrawler())
+      return { ok: false, message: "crawler archive not available yet" };
+    let identity;
+    try {
+      identity = await embedder.identity();
+    } catch (error) {
+      return { ok: false, message: errorMessage2(error) };
+    }
+    this.adoptIdentity(identity);
+    const pruned = this.prune();
+    const pending = this.pendingKeys();
+    const batchSize = Math.max(1, this.options.batchSize ?? DEFAULT_BATCH_SIZE);
+    const budget = Math.max(1, this.options.maxEmbedPerSync ?? DEFAULT_MAX_EMBED_PER_SYNC);
+    const target = Math.min(pending.length, budget);
+    const embed = async (rows) => {
+      const vectors = await embedder.embed(rows.map((row) => row.input));
+      if (vectors.length !== rows.length) {
+        throw new Error(`embedder returned ${vectors.length} vectors for ${rows.length} messages`);
+      }
+      const wrong = vectors.find((vector) => vector.length !== identity.dimension);
+      if (wrong !== undefined) {
+        throw new Error(`embedder returned a ${wrong.length}-dimension vector, expected ${identity.dimension}`);
+      }
+      return vectors;
+    };
+    let embedded = 0;
+    let skipped = 0;
+    for (let offset = 0;offset < target; offset += batchSize) {
+      const rows = [...this.hydrate(pending.slice(offset, Math.min(offset + batchSize, target))).values()];
+      if (rows.length === 0)
+        continue;
+      try {
+        this.store(rows, await embed(rows));
+        embedded += rows.length;
+      } catch (batchError) {
+        const rejected = [];
+        let lastError = batchError;
+        for (const row of rows) {
+          try {
+            this.store([row], await embed([row]));
+            embedded += 1;
+          } catch (error) {
+            rejected.push(row);
+            lastError = error;
+          }
+        }
+        if (rejected.length === 0)
+          continue;
+        if (embedded === 0)
+          return { ok: false, message: errorMessage2(lastError) };
+        this.store(rejected, undefined);
+        skipped += rejected.length;
+      }
+    }
+    return { ok: true, embedded, skipped, pruned, remaining: pending.length - embedded - skipped };
+  }
+  adoptIdentity(identity) {
+    const serialized = JSON.stringify(identity);
+    const current = this.db.prepare("select v from sidecar_meta where k = ?").get(IDENTITY_KEY);
+    if (current?.v === serialized)
+      return;
+    this.transaction(() => {
+      this.db.exec("delete from sidecar_vec");
+      this.db.prepare("insert or replace into sidecar_meta (k, v) values (?, ?)").run(IDENTITY_KEY, serialized);
+    });
+    this.lastSemantic = undefined;
+  }
+  prune() {
+    const { descriptor } = this.options;
+    const result = this.db.prepare(`delete from sidecar_vec where message_key not in (
+					select ${descriptor.keyExpression} from ${descriptor.fromClause} where ${this.where}
+				)`).run(...this.whereParams());
+    if (Number(result.changes) > 0)
+      this.lastSemantic = undefined;
+    return Number(result.changes);
+  }
+  pendingKeys() {
+    const { descriptor } = this.options;
+    const rows = this.db.prepare(`select ${this.select}, v.hash as stored_hash
+				from ${descriptor.fromClause}
+				left join sidecar_vec v on v.message_key = ${descriptor.keyExpression}
+				where ${this.where}`).iterate(...this.whereParams());
+    const pending = [];
+    for (const row of rows) {
+      if (row.stored_hash !== this.toRow(row).hash)
+        pending.push(String(row.k));
+    }
+    return pending;
+  }
+  hydrate(keys) {
+    const { descriptor } = this.options;
+    const out = new Map;
+    if (keys.length === 0)
+      return out;
+    const rows = this.db.prepare(`select ${this.select} from ${descriptor.fromClause}
+				where ${descriptor.keyExpression} in (${keys.map(() => "?").join(", ")}) and ${this.where}`).all(...keys, ...this.whereParams());
+    const byKey = new Map(rows.map((row) => [String(row.k), this.toRow(row)]));
+    for (const key of keys) {
+      const row = byKey.get(key);
+      if (row !== undefined)
+        out.set(key, row);
+    }
+    return out;
+  }
+  store(rows, vectors) {
+    const upsert = this.db.prepare("insert or replace into sidecar_vec (message_key, hash, vec) values (?, ?, ?)");
+    this.transaction(() => {
+      for (const [index, row] of rows.entries()) {
+        upsert.run(row.key, row.hash, encodeVector(vectors?.[index] ?? []));
+      }
+    });
+    this.lastSemantic = undefined;
+  }
+  *storedVectors() {
+    const rows = this.db.prepare("select message_key, vec from sidecar_vec where length(vec) > 0").iterate();
+    for (const row of rows) {
+      const vector = row.vec instanceof Uint8Array ? decodeVector(row.vec) : undefined;
+      if (vector !== undefined)
+        yield { key: String(row.message_key), vector };
+    }
+  }
+  transaction(work) {
+    this.db.exec("begin immediate");
+    try {
+      work();
+      this.db.exec("commit");
+    } catch (error) {
+      this.db.exec("rollback");
+      throw error;
+    }
+  }
+  toRow(row) {
+    const metadata = {};
+    for (const [index, column] of this.options.descriptor.metadata.entries()) {
+      const value = row[`m${index}`];
+      if (typeof value === "string" && value.length > 0 || typeof value === "number")
+        metadata[column.key] = String(value);
+    }
+    const title = typeof row.title === "string" && row.title.length > 0 ? row.title : undefined;
+    const epoch = typeof row.epoch === "number" && Number.isFinite(row.epoch) ? row.epoch : undefined;
+    const content = String(row.content ?? "");
+    const input = `${title ?? ""}
+${content}`.slice(0, MAX_EMBED_INPUT_CHARS);
+    return {
+      key: String(row.k),
+      content,
+      title,
+      epoch,
+      metadata,
+      input,
+      hash: createHash14("sha1").update(input).digest("hex")
+    };
+  }
+  toHit(row, score) {
+    return {
+      key: row.key,
+      content: row.content,
+      score,
+      ...row.title !== undefined ? { title: row.title } : {},
+      ...row.epoch !== undefined ? { publishedAt: Math.round(row.epoch * 1000) } : {},
+      metadata: row.metadata
+    };
+  }
+}
+function toMatchQuery(text) {
+  const terms = [...new Set(text.match(/[\p{L}\p{N}_]+/gu) ?? [])];
+  return terms.length === 0 ? undefined : terms.map((term) => `"${term}"`).join(" OR ");
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var DEFAULT_BATCH_SIZE = 256, DEFAULT_MAX_EMBED_PER_SYNC = 2048, MAX_EMBED_INPUT_CHARS = 8192, BUSY_TIMEOUT_MS = 5000, POOL_FACTOR = 3, SEMANTIC_REUSE_MS = 1e4, IDENTITY_KEY = "identity";
+var init_sidecar = () => {};
+
+// src/datasource/sidecar/methods.ts
+function sidecarMethodName(datasourceId, mode) {
+  return mode === "bm25" ? `${datasourceId}-sidecar-bm25` : `${datasourceId}-${mode}`;
+}
+
+class SidecarRetrievalMethod {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  describe() {
+    const { datasourceId, skillType, mode, tags } = this.options;
+    const { type, text, capabilities } = DESCRIPTIONS[mode];
+    return {
+      name: sidecarMethodName(datasourceId, mode),
+      type,
+      description: `${text} over ${skillType} via a read-only sidecar index`,
+      status: "active",
+      capabilities: [...capabilities, "scoped", "path-opaque-sources"],
+      datasourceId,
+      tags
+    };
+  }
+  async retrieve(query, options) {
+    const trimmed = query.trim();
+    if (trimmed.length === 0)
+      return [];
+    const topK = options.topK ?? DEFAULT_TOP_K5;
+    const { sidecar, mode } = this.options;
+    const hits = mode === "bm25" ? sidecar.searchLexical(trimmed, topK) : mode === "semantic" ? await sidecar.searchSemantic(trimmed, topK) : await sidecar.searchHybrid(trimmed, topK);
+    const results = [];
+    for (const hit of hits) {
+      const result = this.toResult(hit, options);
+      if (result !== undefined)
+        results.push(result);
+    }
+    return results;
+  }
+  toResult(hit, options) {
+    const { descriptor, datasourceId, instanceId, mode } = this.options;
+    const chunkId = descriptor.chunkId(hit.key, hit.metadata);
+    const source = datasourceSourcePath(datasourceId, instanceId, chunkId);
+    if (!matchesDatasourceScope(source, options.scope))
+      return;
+    const method = sidecarMethodName(datasourceId, mode);
+    return {
+      id: `${datasourceId}:${instanceId}:${chunkId}`,
+      content: hit.content,
+      source,
+      score: hit.score,
+      metadata: {
+        ...hit.metadata,
+        method,
+        datasourceId,
+        instanceId,
+        backend: "sidecar",
+        ...hit.title !== undefined ? { title: hit.title } : {},
+        hierarchy: descriptor.hierarchy(hit.metadata).join("/"),
+        ...hit.publishedAt !== undefined ? { publishedAt: hit.publishedAt } : {}
+      }
+    };
+  }
+}
+var DEFAULT_TOP_K5 = 20, DESCRIPTIONS;
+var init_methods5 = __esm(() => {
+  init_scope2();
+  DESCRIPTIONS = {
+    bm25: { type: "bm25", text: "BM25-ranked FTS5 retrieval", capabilities: ["lexical", "fts5", "bm25"] },
+    semantic: { type: "vector", text: "Semantic (embedding) retrieval", capabilities: ["semantic"] },
+    hybrid: {
+      type: "hybrid",
+      text: "Hybrid BM25 + semantic retrieval (reciprocal rank fusion)",
+      capabilities: ["lexical", "semantic", "hybrid"]
+    }
+  };
+});
+
 // src/datasource/crawler-skill.ts
 class CrawlerDatasourceSkill {
   definition;
@@ -26186,6 +27880,7 @@ class CrawlerDatasourceSkill {
   tags;
   channelIds;
   channelNames;
+  sidecar;
   lastIndexedAt;
   constructor(definition, options) {
     this.definition = options.datasourceId === undefined ? definition : {
@@ -26201,6 +27896,11 @@ class CrawlerDatasourceSkill {
     this.lastIndexedAt = options.lastIndexedAt;
     this.channelIds = new Set(options.channelIds ?? []);
     this.channelNames = new Set(options.channelNames ?? []);
+    this.sidecar = options.sidecar === undefined ? undefined : new CrawlerSidecar({
+      ...options.sidecar,
+      channelIds: options.channelIds ?? [],
+      channelNames: options.channelNames ?? []
+    });
   }
   describe() {
     return {
@@ -26236,26 +27936,89 @@ class CrawlerDatasourceSkill {
         skill: this.definition.datasourceId,
         chunkCount: result.count,
         indexedAt: this.lastIndexedAt,
-        diagnostics: []
+        diagnostics: await this.syncSidecar()
       };
     } catch {
       return this.fail("datasource-unavailable", "spawn-error");
     }
   }
+  async syncSidecar() {
+    if (this.sidecar === undefined || !this.sidecar.semanticEnabled)
+      return [];
+    const base = { instanceId: this.instanceId, source: this.definition.datasourceId };
+    let result;
+    try {
+      result = await this.sidecar.sync();
+    } catch (error) {
+      result = { ok: false, message: error instanceof Error ? error.message : String(error) };
+    }
+    if (!result.ok) {
+      return [
+        {
+          code: "datasource-index-failed",
+          severity: "warning",
+          message: `semantic-unavailable: ${result.message}`.slice(0, 300),
+          ...base
+        }
+      ];
+    }
+    const diagnostics = [];
+    if (result.skipped > 0) {
+      diagnostics.push({
+        code: "datasource-index-partial",
+        severity: "warning",
+        message: `semantic index skipped ${result.skipped} message(s) the embedder rejected; they stay searchable by BM25 and are retried when edited`,
+        ...base
+      });
+    }
+    if (result.remaining > 0) {
+      diagnostics.push({
+        code: "datasource-index-partial",
+        severity: "info",
+        message: `semantic index catching up: ${result.embedded} embedded this refresh, ${result.remaining} remaining; hybrid search uses BM25 for the rest until a later refresh`,
+        ...base
+      });
+    }
+    return diagnostics;
+  }
+  close() {
+    this.sidecar?.close();
+  }
   retrievalMethods() {
+    const cli = this.cliMethod();
+    const { sidecar } = this;
+    if (sidecar === undefined)
+      return [cli];
+    const shared = {
+      sidecar,
+      descriptor: sidecar.descriptor,
+      datasourceId: this.definition.datasourceId,
+      skillType: this.definition.skillType,
+      instanceId: this.instanceId,
+      tags: this.tags
+    };
+    const bm25 = new SidecarRetrievalMethod({ ...shared, mode: "bm25" });
+    if (!sidecar.semanticEnabled)
+      return [cli, bm25];
     return [
-      new CrawlerLexicalMethod({
-        client: this.client,
-        datasourceId: this.definition.datasourceId,
-        skillType: this.definition.skillType,
-        instanceId: this.instanceId,
-        tags: this.tags,
-        backendName: this.definition.backendName,
-        channelIds: this.channelIds,
-        channelNames: this.channelNames
-      })
+      cli,
+      bm25,
+      new SidecarRetrievalMethod({ ...shared, mode: "semantic" }),
+      new SidecarRetrievalMethod({ ...shared, mode: "hybrid" })
     ];
   }
+  cliMethod() {
+    return new CrawlerLexicalMethod({
+      client: this.client,
+      datasourceId: this.definition.datasourceId,
+      skillType: this.definition.skillType,
+      instanceId: this.instanceId,
+      tags: this.tags,
+      backendName: this.definition.backendName,
+      channelIds: this.channelIds,
+      channelNames: this.channelNames
+    });
+  }
   describeSources() {
     return this.instances.map((instanceId) => ({
       source: datasourceSourcePath(this.definition.datasourceId, instanceId),
@@ -26386,6 +28149,8 @@ var DEFAULT_INSTANCE_ID5 = "default", DEFAULT_POLLING_INTERVAL_MS4;
 var init_crawler_skill = __esm(() => {
   init_errors4();
   init_scope2();
+  init_sidecar();
+  init_methods5();
   DEFAULT_POLLING_INTERVAL_MS4 = 15 * 60 * 1000;
 });
 
@@ -26538,15 +28303,15 @@ var init_notion = __esm(() => {
 });
 
 // src/datasource/skills/obsidian/paths.ts
-import { join as join35 } from "node:path";
+import { join as join36 } from "node:path";
 function obsidianDatasourceRoot(workspaceRoot, instanceId) {
-  return join35(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, OBSIDIAN_DATASOURCE_DIRNAME, instanceId);
+  return join36(workspaceRoot, AUTORAG_DIRNAME, DATASOURCES_DIRNAME, OBSIDIAN_DATASOURCE_DIRNAME, instanceId);
 }
 function obsidianQmdConfigDir(workspaceRoot, instanceId) {
-  return join35(obsidianDatasourceRoot(workspaceRoot, instanceId), "config");
+  return join36(obsidianDatasourceRoot(workspaceRoot, instanceId), "config");
 }
 function obsidianQmdCacheDir(workspaceRoot, instanceId) {
-  return join35(obsidianDatasourceRoot(workspaceRoot, instanceId), "cache");
+  return join36(obsidianDatasourceRoot(workspaceRoot, instanceId), "cache");
 }
 function stripEdgeDashes(value) {
   let start = 0;
@@ -26569,8 +28334,8 @@ var DEFAULT_QMD_BINARY = "qmd", DEFAULT_QMD_TIMEOUT_MS = 60000, DEFAULT_QMD_MAX_
 
 // src/datasource/skills/obsidian/client.ts
 import { spawn as spawn16 } from "node:child_process";
-import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync22 } from "node:fs";
-import { isAbsolute as isAbsolute8, resolve as resolve14 } from "node:path";
+import { mkdirSync as mkdirSync25, writeFileSync as writeFileSync22 } from "node:fs";
+import { isAbsolute as isAbsolute9, resolve as resolve15 } from "node:path";
 
 class QmdClient {
   options;
@@ -26589,10 +28354,10 @@ class QmdClient {
     const cacheDir = obsidianQmdCacheDir(workspaceRoot, instanceId);
     try {
       if (this.options.configPath === undefined) {
-        mkdirSync24(configDir, { recursive: true });
-        writeFileSync22(resolve14(configDir, "index.yml"), renderIndexYaml(collectionName, vaultPath), "utf8");
+        mkdirSync25(configDir, { recursive: true });
+        writeFileSync22(resolve15(configDir, "index.yml"), renderIndexYaml(collectionName, vaultPath), "utf8");
       }
-      mkdirSync24(cacheDir, { recursive: true });
+      mkdirSync25(cacheDir, { recursive: true });
     } catch (error) {
       return failure4("spawn-error", error instanceof Error ? error.message : "failed to write qmd config");
     }
@@ -26666,7 +28431,7 @@ function resolveVaultPath(vaultPath) {
   if (vaultPath === undefined || vaultPath.trim().length === 0)
     return;
   const trimmed = vaultPath.trim();
-  return isAbsolute8(trimmed) ? trimmed : resolve14(trimmed);
+  return isAbsolute9(trimmed) ? trimmed : resolve15(trimmed);
 }
 function controlledEnv5(options) {
   const instanceId = options.instanceId ?? "default";
@@ -26985,7 +28750,7 @@ async function retrieveObsidian(client, mode, methodName, instanceId, query, opt
   const trimmed = query.trim();
   if (trimmed.length === 0)
     return [];
-  const topK = options.topK ?? DEFAULT_TOP_K5;
+  const topK = options.topK ?? DEFAULT_TOP_K6;
   const searchOptions = { topK, signal: options.signal };
   const result = await client.search(mode, trimmed, searchOptions);
   if (!result.ok)
@@ -27020,8 +28785,8 @@ function toRetrievalResult3(hit, source, methodName, instanceId, mode) {
     }
   };
 }
-var OBSIDIAN_DATASOURCE_ID = "obsidian", DEFAULT_OBSIDIAN_TAGS, DEFAULT_TOP_K5 = 20;
-var init_methods5 = __esm(() => {
+var OBSIDIAN_DATASOURCE_ID = "obsidian", DEFAULT_OBSIDIAN_TAGS, DEFAULT_TOP_K6 = 20;
+var init_methods6 = __esm(() => {
   init_errors4();
   init_scope2();
   DEFAULT_OBSIDIAN_TAGS = ["obsidian", "notes"];
@@ -27211,7 +28976,7 @@ var OBSIDIAN_DATASOURCE_ID2 = "obsidian", OBSIDIAN_SKILL_TYPE = "obsidian-vault"
 var init_skill10 = __esm(() => {
   init_scope2();
   init_client10();
-  init_methods5();
+  init_methods6();
   init_paths5();
   DEFAULT_POLLING_INTERVAL_MS5 = 15 * 60 * 1000;
   DEFAULT_OBSIDIAN_TAGS2 = ["obsidian", "notes"];
@@ -27220,7 +28985,7 @@ var init_skill10 = __esm(() => {
 // src/datasource/skills/obsidian/index.ts
 var init_obsidian = __esm(() => {
   init_client10();
-  init_methods5();
+  init_methods6();
   init_paths5();
   init_skill10();
 });
@@ -27560,7 +29325,7 @@ var init_slack = __esm(() => {
 
 // src/datasource/skills/spotlight/connector.ts
 import { spawn as spawn17 } from "node:child_process";
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 import { readFile as fsReadFile, stat as stat7 } from "node:fs/promises";
 import { basename as basename13, extname as extname8 } from "node:path";
 
@@ -27583,7 +29348,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_MS10;
     const status = await this.run("mdutil", ["-s", "/"], timeoutMs);
     if (status.ok && /indexing disabled/iu.test(status.stdout)) {
       return {
@@ -27645,7 +29410,7 @@ class SpotlightConnector {
         if (content.length === 0)
           continue;
         documents.push({
-          docId: createHash14("sha256").update(path).digest("hex").slice(0, 16),
+          docId: createHash15("sha256").update(path).digest("hex").slice(0, 16),
           hierarchy: ["files"],
           title: basename13(path),
           content,
@@ -27678,7 +29443,7 @@ class SpotlightConnector {
     return { ok: true, documents, ...warnings.length > 0 ? { warnings } : {} };
   }
 }
-var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS5 = 300, DEFAULT_MAX_BYTES_PER_FILE3, DEFAULT_TIMEOUT_MS9 = 15000, MAX_CONTENT_CHARS4 = 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) => {
+var DEFAULT_MAX_RESULTS_PER_QUERY = 100, DEFAULT_MAX_DOCUMENTS5 = 300, DEFAULT_MAX_BYTES_PER_FILE3, DEFAULT_TIMEOUT_MS10 = 15000, MAX_CONTENT_CHARS4 = 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 = spawn17(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
   let stdout = "";
   let stderr = "";
@@ -27795,10 +29560,12 @@ function parseHits3(stdout) {
   for (const [index, row] of rows.entries()) {
     if (!isRecord18(row))
       return;
-    const id = stringValue4(row, ["message_id", "event_id", "id"]);
-    const content = stringValue4(row, ["snippet", "text", "content"]);
-    if (id === undefined || content === undefined)
+    const id = stringValue4(row, ["event_id", "message_id", "id"]);
+    if (id === undefined)
       return;
+    const content = stringValue4(row, ["snippet", "text", "content"]);
+    if (content === undefined)
+      continue;
     const chatId = stringValue4(row, ["chat_jid", "chat_id"]);
     const chatName = stringValue4(row, ["chat_name"]);
     const senderName = stringValue4(row, ["sender_name"]);
@@ -27915,10 +29682,12 @@ function parseHits4(stdout) {
   for (const [index, row] of rows.entries()) {
     if (!isRecord19(row))
       return;
-    const id = stringValue5(row, ["message_id", "event_id", "id"]);
-    const content = stringValue5(row, ["snippet", "text", "content"]);
-    if (id === undefined || content === undefined)
+    const id = stringValue5(row, ["event_id", "message_id", "id"]);
+    if (id === undefined)
       return;
+    const content = stringValue5(row, ["snippet", "text", "content"]);
+    if (content === undefined)
+      continue;
     const chatId = stringValue5(row, ["chat_jid", "chat_id"]);
     const chatName = stringValue5(row, ["chat_name"]);
     const senderName = stringValue5(row, ["sender_name"]);
@@ -28008,6 +29777,31 @@ var init_wacrawl = __esm(() => {
 });
 
 // src/datasource/skills/factory.ts
+import { homedir as homedir4 } from "node:os";
+import { join as join37 } from "node:path";
+function chatCrawlerArgs(descriptor, defaultCrawlerDb, config, workspaceRoot, registrationName) {
+  const sidecar = resolveSidecarOptions({
+    descriptor,
+    connector: config.connector,
+    workspaceRoot,
+    registrationName,
+    instanceId: config.instanceId ?? "default",
+    defaultCrawlerDb
+  });
+  return {
+    datasourceId: registrationName,
+    ...config.instanceId !== undefined ? { instanceId: config.instanceId } : {},
+    ...config.pollingIntervalMs !== undefined ? { pollingIntervalMs: config.pollingIntervalMs } : {},
+    ...config.tags !== undefined ? { tags: config.tags } : {},
+    channelIds: config.channels?.ids,
+    channelNames: config.channels?.names,
+    ...sidecar === undefined ? {} : { sidecar },
+    connectorOptions: {
+      ...config.connector,
+      ...workspaceRoot === undefined ? {} : { workspacePath: workspaceRoot }
+    }
+  };
+}
 function larkConnectorOptions(connector) {
   if (connector === undefined)
     return {};
@@ -28068,6 +29862,8 @@ function buildDatasourceSkills(config, workspaceRoot, embeddingRuntime) {
 var BUILDERS, BUILTIN_DATASOURCE_SKILL_NAMES;
 var init_factory = __esm(() => {
   init_aliased_skill();
+  init_config2();
+  init_descriptors();
   init_clawgallery();
   init_cloud_drive();
   init_discrawl();
@@ -28085,42 +29881,9 @@ var init_factory = __esm(() => {
   init_telecrawl();
   init_wacrawl();
   BUILDERS = {
-    telegram: (config, _workspaceRoot, registrationName) => new TelecrawlSkill({
-      datasourceId: registrationName,
-      ...config.instanceId !== undefined ? { instanceId: config.instanceId } : {},
-      ...config.pollingIntervalMs !== undefined ? { pollingIntervalMs: config.pollingIntervalMs } : {},
-      ...config.tags !== undefined ? { tags: config.tags } : {},
-      channelIds: config.channels?.ids,
-      channelNames: config.channels?.names,
-      connectorOptions: {
-        ...config.connector,
-        ..._workspaceRoot === undefined ? {} : { workspacePath: _workspaceRoot }
-      }
-    }),
-    whatsapp: (config, _workspaceRoot, registrationName) => new WacrawlSkill({
-      datasourceId: registrationName,
-      ...config.instanceId !== undefined ? { instanceId: config.instanceId } : {},
-      ...config.pollingIntervalMs !== undefined ? { pollingIntervalMs: config.pollingIntervalMs } : {},
-      ...config.tags !== undefined ? { tags: config.tags } : {},
-      channelIds: config.channels?.ids,
-      channelNames: config.channels?.names,
-      connectorOptions: {
-        ...config.connector,
-        ..._workspaceRoot === undefined ? {} : { workspacePath: _workspaceRoot }
-      }
-    }),
-    slack: (config, _workspaceRoot, registrationName) => new SlackSkill({
-      datasourceId: registrationName,
-      ...config.instanceId !== undefined ? { instanceId: config.instanceId } : {},
-      ...config.pollingIntervalMs !== undefined ? { pollingIntervalMs: config.pollingIntervalMs } : {},
-      ...config.tags !== undefined ? { tags: config.tags } : {},
-      channelIds: config.channels?.ids,
-      channelNames: config.channels?.names,
-      connectorOptions: {
-        ...config.connector,
-        ..._workspaceRoot === undefined ? {} : { workspacePath: _workspaceRoot }
-      }
-    }),
+    telegram: (config, workspaceRoot, registrationName) => new TelecrawlSkill(chatCrawlerArgs(CRAWLER_DESCRIPTORS.telegram, join37(homedir4(), ".telecrawl", "telecrawl.db"), config, workspaceRoot, registrationName)),
+    whatsapp: (config, workspaceRoot, registrationName) => new WacrawlSkill(chatCrawlerArgs(CRAWLER_DESCRIPTORS.whatsapp, join37(homedir4(), ".wacrawl", "wacrawl.db"), config, workspaceRoot, registrationName)),
+    slack: (config, workspaceRoot, registrationName) => new SlackSkill(chatCrawlerArgs(CRAWLER_DESCRIPTORS.slack, join37(homedir4(), ".slacrawl", "slacrawl.db"), config, workspaceRoot, registrationName)),
     discord: (config, workspaceRoot, registrationName, embeddingRuntime) => {
       const connector = config.connector ?? {};
       const clientOptions = {
@@ -28239,8 +30002,8 @@ var init_factory = __esm(() => {
 
 // src/cli/config.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-import { existsSync as existsSync28, mkdirSync as mkdirSync25, readFileSync as readFileSync24, renameSync as renameSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync23 } from "node:fs";
-import { basename as basename14, dirname as dirname23, isAbsolute as isAbsolute9, join as join36, resolve as resolve15 } from "node:path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync26, readFileSync as readFileSync25, renameSync as renameSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync23 } from "node:fs";
+import { basename as basename14, dirname as dirname25, isAbsolute as isAbsolute10, join as join38, resolve as resolve16 } from "node:path";
 import { findEnvKeys, getEnvApiKey } from "@earendil-works/pi-ai/compat";
 import { getAgentDir as getAgentDir3, ModelRuntime as ModelRuntime2, SettingsManager as SettingsManager2 } from "@earendil-works/pi-coding-agent";
 function resolveConfigPath(input) {
@@ -28256,9 +30019,9 @@ function resolveConfigPath(input) {
     return { configPath: envConfig, explicit: true };
   }
   return {
-    configPath: join36(resolveAutoRAGHome(env), DEFAULT_CONFIG_FILENAME),
+    configPath: join38(resolveAutoRAGHome(env), DEFAULT_CONFIG_FILENAME),
     explicit: false,
-    legacyPath: join36(cwd, LEGACY_CONFIG_FILENAME)
+    legacyPath: join38(cwd, LEGACY_CONFIG_FILENAME)
   };
 }
 function readConfigFile(configPath, explicit) {
@@ -28276,7 +30039,7 @@ function readConfigFile(configPath, explicit) {
   }
   let text;
   try {
-    text = readFileSync24(configPath, "utf8");
+    text = readFileSync25(configPath, "utf8");
   } catch (err) {
     throw new ConfigError(`Failed to read config file: ${err.message}`);
   }
@@ -28314,7 +30077,7 @@ function acquireConfigWriteLock(configPath) {
   });
 }
 function replaceFileAtomically(path, contents, assertCommitAllowed) {
-  const temporaryPath = join36(dirname23(path), `.${basename14(path)}.${process.pid}.${randomUUID9()}.tmp`);
+  const temporaryPath = join38(dirname25(path), `.${basename14(path)}.${process.pid}.${randomUUID9()}.tmp`);
   try {
     writeFileSync23(temporaryPath, contents, { encoding: "utf8", flag: "wx", flush: true, mode: 384 });
     assertCommitAllowed?.();
@@ -28327,12 +30090,12 @@ function migrateLegacyConfig(configPath, legacyPath) {
   if (existsSync28(configPath) || !existsSync28(legacyPath))
     return;
   const legacy = readConfigFile(legacyPath, true);
-  const legacyBytes = readFileSync24(legacyPath);
-  const migrated = normalizeLegacyConfigPaths(legacy ?? {}, dirname23(legacyPath));
+  const legacyBytes = readFileSync25(legacyPath);
+  const migrated = normalizeLegacyConfigPaths(legacy ?? {}, dirname25(legacyPath));
   const migratedPathsUnchanged = legacy?.workspacePath === migrated.workspacePath && legacy?.memoryPath === migrated.memoryPath && JSON.stringify(legacy?.searchPaths) === JSON.stringify(migrated.searchPaths);
   const migratedBytes = migratedPathsUnchanged ? legacyBytes : `${JSON.stringify(migrated, null, 2)}
 `;
-  mkdirSync25(dirname23(configPath), { recursive: true });
+  mkdirSync26(dirname25(configPath), { recursive: true });
   const lock = acquireConfigWriteLock(configPath);
   try {
     const winner = readConfigFile(configPath, false);
@@ -28362,13 +30125,13 @@ function resolveConfigFileReadOnly(configPath, explicit, legacyPath) {
   const legacy = readConfigFile(legacyPath, false);
   if (legacy === undefined)
     return {};
-  return normalizeLegacyConfigPaths(legacy, dirname23(legacyPath));
+  return normalizeLegacyConfigPaths(legacy, dirname25(legacyPath));
 }
 function resolveSearchPaths(searchPaths, origin) {
   return searchPaths.map((searchPath) => resolvePersistedPath(searchPath, origin));
 }
 function resolvePersistedPath(path, origin) {
-  return isAbsolute9(path) ? path : resolve15(origin, path);
+  return isAbsolute10(path) ? path : resolve16(origin, path);
 }
 function normalizeLegacyConfigPaths(partial, origin) {
   const workspacePath = resolvePersistedPath(partial.workspacePath ?? ".", origin);
@@ -28555,7 +30318,7 @@ function normalizeEmbedder(raw, path) {
     out.passagePrefix = record.passagePrefix;
   }
   if (record.profile !== undefined) {
-    if (record.profile !== "qwen3-embedding-0.6b" && record.profile !== "embeddinggemma-300m") {
+    if (record.profile !== "qwen3-embedding-0.6b") {
       throw new ConfigError(`${path}.profile must be a supported runtime profile`);
     }
     out.profile = record.profile;
@@ -28798,10 +30561,10 @@ function resolveConfig(input) {
   const file = readOnly ? resolveConfigFileReadOnly(configPath, explicit, legacyPath) : !explicit && legacyPath ? migrateLegacyConfig(configPath, legacyPath) ?? readConfigFile(configPath, explicit) ?? {} : readConfigFile(configPath, explicit) ?? {};
   const defaultSearchPaths = ["."];
   const defaultWorkspacePath = cwd;
-  const defaultMemoryPath = join36(resolveAutoRAGHome(env), "memory.json");
+  const defaultMemoryPath = join38(resolveAutoRAGHome(env), "memory.json");
   const flagSearchPaths = parseCsv(flagString(flags, "search-paths"));
   const envSearchPaths = parseCsv(envString(env, "AUTORAG_SEARCH_PATHS"));
-  const configOrigin = dirname23(resolve15(configPath));
+  const configOrigin = dirname25(resolve16(configPath));
   const fileWorkspacePath = typeof file.workspacePath === "string" ? resolvePersistedPath(file.workspacePath, configOrigin) : undefined;
   const fileSearchPaths = file.searchPaths ? resolveSearchPaths(file.searchPaths, fileWorkspacePath ?? configOrigin) : undefined;
   if (file.excludePaths !== undefined && (!Array.isArray(file.excludePaths) || file.excludePaths.some((path) => typeof path !== "string" || path.length === 0))) {
@@ -28824,7 +30587,7 @@ function resolveConfig(input) {
   const flagModelId = pickString(flags, env, "model-id", "AUTORAG_MODEL_ID", undefined);
   const model = applyRoleFlagOverrides(fileModel, flagModelProvider, flagModelId, "model");
   const config = {
-    configPath: resolve15(configPath),
+    configPath: resolve16(configPath),
     searchPaths,
     workspacePath,
     memoryPath,
@@ -29000,36 +30763,38 @@ function buildWebSearchAgentOption(raw) {
 function normalizeRerankConfig(raw, path) {
   if (raw === false)
     return false;
-  const out = {
-    provider: DEFAULT_RERANK_PROVIDER,
-    model: DEFAULT_RERANK_MODEL,
-    apiKeyEnv: DEFAULT_RERANK_API_KEY_ENV,
-    topN: DEFAULT_RERANK_TOP_N
-  };
-  if (raw === undefined || raw === null)
-    return out;
-  if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw new ConfigError(`${path} must be an object or false`);
-  }
-  const record = raw;
-  for (const key of Object.keys(record)) {
-    if (!RERANK_ALLOWLIST.has(key))
-      throw new ConfigError(`${path}.${key} is not a recognized field`);
-  }
-  if (record.enabled !== undefined) {
-    if (typeof record.enabled !== "boolean")
-      throw new ConfigError(`${path}.enabled must be a boolean`);
-    out.enabled = record.enabled;
+  let record = {};
+  if (raw !== undefined && raw !== null) {
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+      throw new ConfigError(`${path} must be an object or false`);
+    }
+    record = raw;
+    for (const key of Object.keys(record)) {
+      if (!RERANK_ALLOWLIST.has(key))
+        throw new ConfigError(`${path}.${key} is not a recognized field`);
+    }
   }
+  let provider = DEFAULT_RERANK_PROVIDER;
   if (record.provider !== undefined) {
     if (typeof record.provider !== "string" || record.provider.trim() === "") {
       throw new ConfigError(`${path}.provider must be a non-empty string`);
     }
-    out.provider = record.provider.trim();
+    provider = record.provider.trim();
   }
-  if (!SUPPORTED_RERANK_PROVIDERS.includes(out.provider ?? "")) {
+  if (!SUPPORTED_RERANK_PROVIDERS.includes(provider)) {
     throw new ConfigError(`${path}.provider must be one of: ${SUPPORTED_RERANK_PROVIDERS.join(", ")}`);
   }
+  const out = {
+    provider,
+    model: defaultRerankModel(provider),
+    apiKeyEnv: defaultRerankApiKeyEnv(provider),
+    topN: DEFAULT_RERANK_TOP_N
+  };
+  if (record.enabled !== undefined) {
+    if (typeof record.enabled !== "boolean")
+      throw new ConfigError(`${path}.enabled must be a boolean`);
+    out.enabled = record.enabled;
+  }
   if (record.model !== undefined) {
     if (typeof record.model !== "string" || record.model.trim() === "") {
       throw new ConfigError(`${path}.model must be a non-empty string`);
@@ -29159,7 +30924,8 @@ function buildModelFromConfiguredEndpoint(reference) {
     input: reference.input ?? ["text"],
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
     contextWindow: reference.contextWindow ?? 128000,
-    maxTokens: reference.maxTokens ?? 16384
+    maxTokens: reference.maxTokens ?? 16384,
+    ...reference.provider === PROVIDER_ID ? { inputLimits: AUTORAG_INPUT_LIMITS } : {}
   };
 }
 function mergeCatalogModel(catalog, reference) {
@@ -29210,8 +30976,8 @@ function getModelRuntime(agentDir) {
     return cached;
   const created = (async () => {
     const runtime = await ModelRuntime2.create({
-      authPath: join36(agentDir, "auth.json"),
-      modelsPath: join36(agentDir, "models.json"),
+      authPath: join38(agentDir, "auth.json"),
+      modelsPath: join38(agentDir, "models.json"),
       allowModelNetwork: false
     });
     await registerAutoRAGProvider(runtime);
@@ -29470,7 +31236,7 @@ function writeConfigObject(path, config) {
   if (config === null || typeof config !== "object" || Array.isArray(config)) {
     throw new ConfigError("Config file must be a JSON object");
   }
-  mkdirSync25(dirname23(path), { recursive: true });
+  mkdirSync26(dirname25(path), { recursive: true });
   const contents = `${JSON.stringify(config, null, 2)}
 `;
   const lock = acquireConfigWriteLock(path);
@@ -29481,9 +31247,9 @@ function writeConfigObject(path, config) {
   }
 }
 function writeDefaultConfig(path, partial, opts = {}) {
-  const cwd = resolve15(opts.cwd ?? process.cwd());
+  const cwd = resolve16(opts.cwd ?? process.cwd());
   const workspacePath = resolvePersistedPath(partial.workspacePath ?? ".", cwd);
-  const memoryPath = partial.memoryPath === undefined ? join36(resolveAutoRAGHome(opts.env), "memory.json") : resolvePersistedPath(partial.memoryPath, workspacePath);
+  const memoryPath = partial.memoryPath === undefined ? join38(resolveAutoRAGHome(opts.env), "memory.json") : resolvePersistedPath(partial.memoryPath, workspacePath);
   const full = {
     searchPaths: resolveSearchPaths(partial.searchPaths ?? ["."], cwd),
     workspacePath,
@@ -29517,7 +31283,7 @@ function writeDefaultConfig(path, partial, opts = {}) {
     full.p2p = { enabled: false };
   full.jev = partial.jev ?? { backend: DEFAULT_JEV_BACKEND };
   full.queryDecomposition = partial.queryDecomposition ?? { model: { ...DEFAULT_QUERY_DECOMPOSITION_MODEL } };
-  mkdirSync25(dirname23(path), { recursive: true });
+  mkdirSync26(dirname25(path), { recursive: true });
   const contents = `${JSON.stringify(full, null, 2)}
 `;
   const lock = acquireConfigWriteLock(path);
@@ -29545,8 +31311,9 @@ function writeDefaultConfig(path, partial, opts = {}) {
   }
 }
 var DEFAULT_CONFIG_FILENAME = "config.json", LEGACY_CONFIG_FILENAME = "autorag.config.json", CONFIG_LOCK_RETRY_MS = 10, CONFIG_LOCK_TIMEOUT_MS = 1e4, CONFIG_LOCK_STALE_MS = 30000, ConfigError, MINSYNC_REQUIRED_MESSAGE = "MinSync is required and cannot be disabled; remove `minSync: false` / `minSync.enabled: false` from the config.", AGENT_MODEL_APIS, AGENT_MODEL_INPUTS, API_KEY_ENV_PATTERN2, POSITIVE_INT_FIELDS, EMBEDDER_ALLOWLIST, MINSYNC_ALLOWLIST, MINSYNC_LEGACY_IGNORED, P2P_ALLOWLIST, P2P_QUOTA_ALLOWLIST, LIMITS_ALLOWLIST, LIMITS_PREFETCH_ALLOWLIST, JEV_CONFIG_FIELDS, JEV_BACKEND_NAMES, DEFAULT_JEV_BACKEND = "openrouter", DEFAULT_QUERY_DECOMPOSITION_MODEL, RERANK_ALLOWLIST, UNKNOWN_MODEL_HINT = "Add baseUrl (and optional api/apiKeyEnv) for an OpenAI-compatible endpoint outside the pi-ai catalog, or use a pi-ai catalog model id.", modelRuntimeCache;
-var init_config3 = __esm(() => {
+var init_config4 = __esm(() => {
   init_local_model();
+  init_config();
   init_provider();
   init_home();
   init_factory();
@@ -29628,7 +31395,7 @@ var init_config3 = __esm(() => {
     model: true,
     confidenceThreshold: true
   };
-  JEV_BACKEND_NAMES = ["typesafe", "openrouter", "vercel"];
+  JEV_BACKEND_NAMES = ["typesafe", "openrouter", "vercel", "autorag"];
   DEFAULT_QUERY_DECOMPOSITION_MODEL = { provider: "openrouter", id: "qwen/qwen3.7-flash" };
   RERANK_ALLOWLIST = new Set(["enabled", "provider", "model", "apiKeyEnv", "baseUrl", "topN", "timeoutMs"]);
   modelRuntimeCache = new Map;
@@ -29718,9 +31485,9 @@ function createAutoRAGLite(options = {}) {
 var init_core = __esm(() => {
   init_agent();
   init_search_documents();
-  init_config3();
+  init_config4();
   init_memory();
-  init_config3();
+  init_config4();
 });
 
 // src/cli/output.ts
@@ -30165,16 +31932,16 @@ async function runEvidence(ctx) {
 }
 var init_evidence = __esm(() => {
   init_memory();
-  init_config3();
+  init_config4();
 });
 
 // src/cli/commands/report.ts
-import { readFileSync as readFileSync25 } from "node:fs";
+import { readFileSync as readFileSync26 } from "node:fs";
 import { Value as Value3 } from "typebox/value";
 function readReportInput(input) {
   if (typeof input === "string" && input.length > 0)
-    return readFileSync25(input, "utf8");
-  return readFileSync25(0, "utf8");
+    return readFileSync26(input, "utf8");
+  return readFileSync26(0, "utf8");
 }
 function describeSchemaErrors(value) {
   const errors = Value3.Errors(reportSchema, value);
@@ -30265,7 +32032,7 @@ var MAX_REPORTED_SCHEMA_ERRORS = 8;
 var init_report = __esm(() => {
   init_results();
   init_core();
-  init_config3();
+  init_config4();
 });
 
 // src/mirror/index.ts
@@ -30504,8 +32271,8 @@ init_loader();
 init_evidence();
 init_report();
 init_dupey();
-import { readFileSync as readFileSync26 } from "node:fs";
-import { resolve as resolve17 } from "node:path";
+import { readFileSync as readFileSync27 } from "node:fs";
+import { resolve as resolve18 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { McpServer } from "@modelcontextprotocol/server";
 import { z as z2 } from "zod";
@@ -30513,7 +32280,7 @@ import { z as z2 } from "zod";
 // src/filesystem/name-search.ts
 import { realpathSync as realpathSync6 } from "node:fs";
 import { lstat, readdir as readdir4 } from "node:fs/promises";
-import { basename as basename15, dirname as dirname24, isAbsolute as isAbsolute10, join as join37, relative as relative6, resolve as resolve16, sep as sep7 } from "node:path";
+import { basename as basename15, dirname as dirname26, isAbsolute as isAbsolute11, join as join39, relative as relative6, resolve as resolve17, sep as sep8 } from "node:path";
 var SKIP_DIR_NAMES2 = {
   ".git": true,
   ".autorag": true,
@@ -30541,27 +32308,27 @@ function fsErrorCode(error) {
   return typeof code === "string" ? code : undefined;
 }
 function isContained(childReal, parentReal) {
-  const prefix = parentReal.endsWith(sep7) ? parentReal : `${parentReal}${sep7}`;
+  const prefix = parentReal.endsWith(sep8) ? parentReal : `${parentReal}${sep8}`;
   return childReal === parentReal || childReal.startsWith(prefix);
 }
 function pinExcludedPath2(path) {
-  const resolvedPath = resolve16(path);
+  const resolvedPath = resolve17(path);
   try {
-    return join37(realpathSync6(dirname24(resolvedPath)), basename15(resolvedPath));
+    return join39(realpathSync6(dirname26(resolvedPath)), basename15(resolvedPath));
   } catch {
     return resolvedPath;
   }
 }
 function isExcluded2(absPath, excluded) {
   for (const excludedPath of excluded) {
-    const prefix = excludedPath.endsWith(sep7) ? excludedPath : `${excludedPath}${sep7}`;
+    const prefix = excludedPath.endsWith(sep8) ? excludedPath : `${excludedPath}${sep8}`;
     if (absPath === excludedPath || absPath.startsWith(prefix))
       return true;
   }
   return false;
 }
 function matchesEntry(context, absPath, name) {
-  const haystackRaw = context.matchPath ? relative6(context.rootReal, absPath).split(sep7).join("/") : name;
+  const haystackRaw = context.matchPath ? relative6(context.rootReal, absPath).split(sep8).join("/") : name;
   const haystack = context.matchCase ? haystackRaw : haystackRaw.toLowerCase();
   const needle = context.matchCase ? context.query : context.query.toLowerCase();
   return haystack.includes(needle);
@@ -30601,7 +32368,7 @@ async function walkDirectory(context, directory) {
     }
     if (entry.isSymbolicLink())
       continue;
-    const absPath = join37(directory, entry.name);
+    const absPath = join39(directory, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIR_NAMES2[entry.name] === true)
         continue;
@@ -30638,7 +32405,7 @@ async function pinConfiguredRoots(roots, diagnostics) {
   for (const root of roots) {
     if (typeof root !== "string" || root.length === 0)
       continue;
-    const resolvedRoot = resolve16(root);
+    const resolvedRoot = resolve17(root);
     let real;
     try {
       real = realpathSync6(resolvedRoot);
@@ -30660,7 +32427,7 @@ async function pinConfiguredRoots(roots, diagnostics) {
   return outermost;
 }
 async function resolveRequestRoots(requestRoot, pinnedRoots) {
-  const candidates = isAbsolute10(requestRoot) ? [requestRoot] : pinnedRoots.map((root) => resolve16(root, requestRoot));
+  const candidates = isAbsolute11(requestRoot) ? [requestRoot] : pinnedRoots.map((root) => resolve17(root, requestRoot));
   const allowed = [];
   for (const candidate of candidates) {
     let real;
@@ -30702,7 +32469,7 @@ async function filterFileNameSearchMatches(roots, candidates, excludePaths = [])
       continue;
     if (isExcluded2(real, excluded))
       continue;
-    const segments = real.split(sep7);
+    const segments = real.split(sep8);
     if (segments.some((segment) => SKIP_DIR_NAMES2[segment] === true))
       continue;
     matches.push({ path: real, type: stat.isDirectory() ? "folder" : "file" });
@@ -30851,7 +32618,7 @@ function isToolEnabled(name, options) {
 }
 function readPackageVersion() {
   try {
-    const manifest = JSON.parse(readFileSync26(fileURLToPath3(new URL("../../package.json", import.meta.url)), "utf8"));
+    const manifest = JSON.parse(readFileSync27(fileURLToPath3(new URL("../../package.json", import.meta.url)), "utf8"));
     if (typeof manifest === "object" && manifest !== null && "version" in manifest && typeof manifest.version === "string") {
       return manifest.version;
     }
@@ -31090,7 +32857,7 @@ function createAutoRAGMcpServer(lite, options = {}) {
           ...configuredDupey.timeoutMs !== undefined ? { timeoutMs: configuredDupey.timeoutMs } : {},
           ...configuredDupey.run !== undefined ? { run: configuredDupey.run } : {}
         };
-        const roots = lite.config.searchPaths.map((path) => resolve17(path));
+        const roots = lite.config.searchPaths.map((path) => resolve18(path));
         const scans = await Promise.all(roots.map((root) => scanWithDupey(root, dupeyOptions)));
         return jsonResult({
           ok: true,
@@ -31232,6 +32999,8 @@ export {
   ConnectorDatasourceSkill,
   ConnectorLexicalMethod,
   DATASOURCE_CHUNKS_SEGMENT,
+  DEFAULT_AUTORAG_RERANK_API_KEY_ENV,
+  DEFAULT_AUTORAG_RERANK_MODEL,
   DEFAULT_BASE_URL,
   DEFAULT_CONTEXT_WINDOW,
   DEFAULT_DISCRAWL_EMBEDDING_MODEL,
@@ -31331,7 +33100,7 @@ export {
   WacrawlSkill,
   base64UrlEncode,
   bm25Scores,
-  boundDiagnosticText2 as boundDiagnosticText,
+  boundDiagnosticText,
   buildAgentOptions,
   buildAuthorizeUrl,
   buildDatasourceChunkSource,
@@ -31361,6 +33130,8 @@ export {
   datasourceChunkStorePath,
   datasourceSourceHasFragment,
   datasourceSourcePath,
+  defaultRerankApiKeyEnv,
+  defaultRerankModel,
   derivedDatasourceIds,
   describeRetrievalError,
   detectMirrorStaleness,