open-codebase-index 0.22.5 → 0.24.0

package/dist/cli.cjs

@@ -496,7 +496,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path31, checkUnignored, mode) {
+      test(path33, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -505,7 +505,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path31);
+          const matched = rule[mode].test(path33);
           if (!matched) {
             return;
           }
@@ -526,17 +526,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path31, originalPath, doThrow) => {
-      if (!isString(path31)) {
+    var checkPath = (path33, originalPath, doThrow) => {
+      if (!isString(path33)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path31) {
+      if (!path33) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path31)) {
+      if (checkPath.isNotRelative(path33)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -545,7 +545,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path31) => REGEX_TEST_INVALID_PATH.test(path31);
+    var isNotRelative = (path33) => REGEX_TEST_INVALID_PATH.test(path33);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -575,19 +575,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path31 = originalPath && checkPath.convert(originalPath);
+        const path33 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path31,
+          path33,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path31, cache, checkUnignored, slices);
+        return this._t(path33, cache, checkUnignored, slices);
       }
-      checkIgnore(path31) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path31)) {
-          return this.test(path31);
+      checkIgnore(path33) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path33)) {
+          return this.test(path33);
         }
-        const slices = path31.split(SLASH2).filter(Boolean);
+        const slices = path33.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -600,18 +600,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path31, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path33, false, MODE_CHECK_IGNORE);
       }
-      _t(path31, cache, checkUnignored, slices) {
-        if (path31 in cache) {
-          return cache[path31];
+      _t(path33, cache, checkUnignored, slices) {
+        if (path33 in cache) {
+          return cache[path33];
         }
         if (!slices) {
-          slices = path31.split(SLASH2).filter(Boolean);
+          slices = path33.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path31] = this._rules.test(path31, checkUnignored, MODE_IGNORE);
+          return cache[path33] = this._rules.test(path33, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -619,29 +619,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path31] = parent.ignored ? parent : this._rules.test(path31, checkUnignored, MODE_IGNORE);
+        return cache[path33] = parent.ignored ? parent : this._rules.test(path33, checkUnignored, MODE_IGNORE);
       }
-      ignores(path31) {
-        return this._test(path31, this._ignoreCache, false).ignored;
+      ignores(path33) {
+        return this._test(path33, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path31) => !this.ignores(path31);
+        return (path33) => !this.ignores(path33);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path31) {
-        return this._test(path31, this._testCache, true);
+      test(path33) {
+        return this._test(path33, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path31) => checkPath(path31 && checkPath.convert(path31), path31, RETURN_FALSE);
+    var isPathValid = (path33) => checkPath(path33 && checkPath.convert(path33), path33, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path31) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path31) || isNotRelative(path31);
+      checkPath.isNotRelative = (path33) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path33) || isNotRelative(path33);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -669,7 +669,7 @@ module.exports = __toCommonJS(cli_exports);
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_fs20 = require("fs");
 var os8 = __toESM(require("os"), 1);
-var path30 = __toESM(require("path"), 1);
+var path32 = __toESM(require("path"), 1);
 var import_url = require("url");
 
 // src/config/constants.ts
@@ -730,6 +730,17 @@ var EMBEDDING_MODELS = {
       maxTokens: 2048,
       costPer1MTokens: 0.15,
       taskAble: true
+    },
+    "gemini-embedding-2": {
+      provider: "google",
+      model: "gemini-embedding-2",
+      // Keep a conservative, testable default embedding dimension. Gemini Embedding 2 supports
+      // flexible dimensions via outputDimensionality.
+      dimensions: 1536,
+      maxTokens: 8192,
+      costPer1MTokens: 0.15,
+      taskAble: false,
+      promptStyle: "embedding-2"
     }
   },
   "openai": {
@@ -763,26 +774,15 @@ var EMBEDDING_MODELS = {
       maxTokens: 512,
       costPer1MTokens: 0
     }
-  },
-  "github-copilot": {
-    "text-embedding-3-small": {
-      provider: "github-copilot",
-      model: "text-embedding-3-small",
-      dimensions: 1536,
-      maxTokens: 8191,
-      costPer1MTokens: 0
-    }
   }
 };
 var DEFAULT_PROVIDER_MODELS = {
-  "github-copilot": "text-embedding-3-small",
   "openai": "text-embedding-3-small",
   "google": "gemini-embedding-001",
   "ollama": "nomic-embed-text"
 };
 var AUTO_DETECT_PROVIDER_ORDER = [
   "ollama",
-  "github-copilot",
   "openai",
   "google"
 ];
@@ -808,6 +808,9 @@ function getDefaultIndexingConfig() {
     maxDepth: 5,
     maxFilesPerDirectory: 100,
     fallbackToTextOnMaxChunks: true,
+    // Must stay in sync with DEFAULT_LINES_PER_CHUNK in native/src/lib.rs (the napi
+    // fallback used when a native caller omits the argument).
+    linesPerChunk: 30,
     gitBlame: { enabled: false }
   };
 }
@@ -941,6 +944,7 @@ function parseConfig(raw) {
     maxDepth: typeof rawIndexing.maxDepth === "number" ? rawIndexing.maxDepth < -1 ? -1 : rawIndexing.maxDepth : defaultIndexing.maxDepth,
     maxFilesPerDirectory: typeof rawIndexing.maxFilesPerDirectory === "number" ? Math.max(1, rawIndexing.maxFilesPerDirectory) : defaultIndexing.maxFilesPerDirectory,
     fallbackToTextOnMaxChunks: typeof rawIndexing.fallbackToTextOnMaxChunks === "boolean" ? rawIndexing.fallbackToTextOnMaxChunks : defaultIndexing.fallbackToTextOnMaxChunks,
+    linesPerChunk: typeof rawIndexing.linesPerChunk === "number" && Number.isFinite(rawIndexing.linesPerChunk) ? Math.min(Math.max(1, Math.floor(rawIndexing.linesPerChunk)), 4294967295) : defaultIndexing.linesPerChunk,
     gitBlame: {
       enabled: rawIndexing.gitBlame && typeof rawIndexing.gitBlame === "object" && typeof rawIndexing.gitBlame.enabled === "boolean" ? rawIndexing.gitBlame.enabled : defaultIndexing.gitBlame.enabled
     }
@@ -983,6 +987,7 @@ function parseConfig(raw) {
   let embeddingModel;
   let customProvider;
   let reranker;
+  const githubCopilotDeprecationMessage = '`embeddingProvider: "github-copilot"` is deprecated and no longer available. Migrate existing configs to `embeddingProvider: "google"` and select an explicit Google model. For existing indexes, run `index_codebase` with `force: true` after changing to `gemini-embedding-001` or `gemini-embedding-2` to rebuild embeddings. See docs/configuration.md for details.';
   if (embeddingProviderValue === "custom") {
     embeddingProvider = "custom";
     const rawCustom = input.customProvider && typeof input.customProvider === "object" ? input.customProvider : null;
@@ -1022,6 +1027,8 @@ function parseConfig(raw) {
     } else if (rawEmbeddingModel) {
       embeddingModel = DEFAULT_PROVIDER_MODELS[embeddingProvider];
     }
+  } else if (embeddingProviderValue === "github-copilot") {
+    throw new Error(githubCopilotDeprecationMessage);
   } else {
     embeddingProvider = "auto";
   }
@@ -1052,10 +1059,21 @@ function parseConfig(raw) {
       timeoutMs: typeof rawReranker.timeoutMs === "number" ? Math.max(1e3, Math.floor(rawReranker.timeoutMs)) : 1e4
     };
   }
+  const rawEmbedding = input.embedding && typeof input.embedding === "object" ? input.embedding : {};
+  const rawEmbeddingBatch = rawEmbedding.batch && typeof rawEmbedding.batch === "object" ? rawEmbedding.batch : null;
+  const embeddingMaxBatchItems = typeof rawEmbeddingBatch?.maxBatchItems === "number" && Number.isFinite(rawEmbeddingBatch.maxBatchItems) ? Math.max(1, Math.floor(rawEmbeddingBatch.maxBatchItems)) : void 0;
+  const embeddingMaxBatchTokens = typeof rawEmbeddingBatch?.maxBatchTokens === "number" && Number.isFinite(rawEmbeddingBatch.maxBatchTokens) ? Math.max(1, Math.floor(rawEmbeddingBatch.maxBatchTokens)) : void 0;
+  const embedding = embeddingMaxBatchItems !== void 0 || embeddingMaxBatchTokens !== void 0 ? {
+    batch: {
+      ...embeddingMaxBatchItems !== void 0 ? { maxBatchItems: embeddingMaxBatchItems } : {},
+      ...embeddingMaxBatchTokens !== void 0 ? { maxBatchTokens: embeddingMaxBatchTokens } : {}
+    }
+  } : {};
   return {
     embeddingProvider,
     embeddingModel,
     customProvider,
+    embedding,
     scope: isValidScope(scopeValue) ? scopeValue : "project",
     include: includeValue ?? DEFAULT_INCLUDE,
     exclude: excludeValue ?? DEFAULT_EXCLUDE,
@@ -1179,9 +1197,9 @@ var import_fs = require("fs");
 var path = __toESM(require("path"), 1);
 
 // src/eval/report-formatters.ts
-function assertFiniteNumber(value, path31) {
+function assertFiniteNumber(value, path33) {
   if (typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value)) {
-    throw new Error(`${path31} must be a finite number`);
+    throw new Error(`${path33} must be a finite number`);
   }
   return value;
 }
@@ -1453,7 +1471,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve18, reject) => {
+  const wrappedPromise = new Promise((resolve20, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -1467,7 +1485,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve18, reject);
+    promise.then(resolve20, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -1475,7 +1493,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve18(fallback());
+          resolve20(fallback());
         } catch (error) {
           reject(error);
         }
@@ -1485,7 +1503,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve18();
+        resolve20();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1887,7 +1905,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve18, reject) => {
+    return new Promise((resolve20, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -1927,7 +1945,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve18(result);
+          resolve20(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -2115,13 +2133,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve18) => {
+    return new Promise((resolve20) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve18();
+        resolve20();
       };
       this.on(event, listener);
     });
@@ -2407,7 +2425,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve18, reject) => {
+    await new Promise((resolve20, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -2415,7 +2433,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve18();
+        resolve20();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -2551,8 +2569,6 @@ async function tryDetectProvider() {
 }
 async function getProviderCredentials(provider) {
   switch (provider) {
-    case "github-copilot":
-      return getGitHubCopilotCredentials();
     case "openai":
       return getOpenAICredentials();
     case "google":
@@ -2563,22 +2579,6 @@ async function getProviderCredentials(provider) {
       return null;
   }
 }
-function getGitHubCopilotCredentials() {
-  const authData = loadOpenCodeAuth();
-  const copilotAuth = authData["github-copilot"] || authData["github-copilot-enterprise"];
-  if (!copilotAuth || copilotAuth.type !== "oauth") {
-    return null;
-  }
-  const auth = copilotAuth;
-  const baseUrl = auth.enterpriseUrl ? `https://copilot-api.${auth.enterpriseUrl.replace(/^https?:\/\//, "").replace(/\/$/, "")}` : "https://models.github.ai";
-  return {
-    provider: "github-copilot",
-    baseUrl,
-    refreshToken: copilotAuth.refresh,
-    accessToken: copilotAuth.access,
-    tokenExpires: copilotAuth.expires
-  };
-}
 function getOpenAICredentials() {
   const authData = loadOpenCodeAuth();
   const openaiAuth = authData["openai"];
@@ -2704,8 +2704,6 @@ async function tryDetectOllamaProvider() {
 }
 function getProviderDisplayName(provider) {
   switch (provider) {
-    case "github-copilot":
-      return "GitHub Copilot";
     case "openai":
       return "OpenAI";
     case "google":
@@ -2930,44 +2928,6 @@ var CustomEmbeddingProvider = class extends BaseEmbeddingProvider {
   }
 };
 
-// src/embeddings/providers/github-copilot.ts
-var GitHubCopilotEmbeddingProvider = class extends BaseEmbeddingProvider {
-  constructor(credentials, modelInfo) {
-    super(credentials, modelInfo);
-  }
-  getToken() {
-    if (!this.credentials.refreshToken) {
-      throw new Error("No OAuth token available for GitHub");
-    }
-    return this.credentials.refreshToken;
-  }
-  async embedBatch(texts) {
-    const token = this.getToken();
-    const response = await fetch(`${this.credentials.baseUrl}/inference/embeddings`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json",
-        Accept: "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28"
-      },
-      body: JSON.stringify({
-        model: `openai/${this.modelInfo.model}`,
-        input: texts
-      })
-    });
-    if (!response.ok) {
-      const error = (await response.text()).slice(0, 500);
-      throw new Error(`GitHub Copilot embedding API error: ${response.status} - ${error}`);
-    }
-    const data = await response.json();
-    return {
-      embeddings: data.data.map((d) => d.embedding),
-      totalTokensUsed: data.usage.total_tokens
-    };
-  }
-};
-
 // src/embeddings/providers/google.ts
 var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider extends BaseEmbeddingProvider {
   static BATCH_SIZE = 20;
@@ -2975,24 +2935,30 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider extends BaseEmbeddi
     super(credentials, modelInfo);
   }
   async embedQuery(query) {
-    const taskType = this.modelInfo.taskAble ? "CODE_RETRIEVAL_QUERY" : void 0;
-    const result = await this.embedWithTaskType([query], taskType);
+    const taskType = this.modelInfo.model === "gemini-embedding-001" && this.modelInfo.taskAble ? "CODE_RETRIEVAL_QUERY" : void 0;
+    const texts = [
+      this.modelInfo.model === "gemini-embedding-2" ? `task: code retrieval | query: ${query}` : query
+    ];
+    const result = await this.embedWithTaskType(texts, taskType);
     return {
       embedding: result.embeddings[0],
       tokensUsed: result.totalTokensUsed
     };
   }
   async embedDocument(document) {
-    const taskType = this.modelInfo.taskAble ? "RETRIEVAL_DOCUMENT" : void 0;
-    const result = await this.embedWithTaskType([document], taskType);
+    const taskType = this.modelInfo.model === "gemini-embedding-001" && this.modelInfo.taskAble ? "RETRIEVAL_DOCUMENT" : void 0;
+    const result = await this.embedWithTaskType([
+      this.modelInfo.model === "gemini-embedding-2" ? `title: none | text: ${document}` : document
+    ], taskType);
     return {
       embedding: result.embeddings[0],
       tokensUsed: result.totalTokensUsed
     };
   }
   async embedBatch(texts) {
-    const taskType = this.modelInfo.taskAble ? "RETRIEVAL_DOCUMENT" : void 0;
-    return this.embedWithTaskType(texts, taskType);
+    const taskType = this.modelInfo.model === "gemini-embedding-001" && this.modelInfo.taskAble ? "RETRIEVAL_DOCUMENT" : void 0;
+    const formattedTexts = this.modelInfo.model === "gemini-embedding-2" ? texts.map((text) => `title: none | text: ${text}`) : texts;
+    return this.embedWithTaskType(formattedTexts, taskType);
   }
   async embedWithTaskType(texts, taskType) {
     const batches = [];
@@ -3042,6 +3008,10 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider extends BaseEmbeddi
 var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddingProvider {
   static MIN_TRUNCATION_CHARS = 512;
   static REQUEST_TIMEOUT_MS = 12e4;
+  // Set when /api/embed returns 404 so subsequent multi-text batches skip the
+  // batched endpoint and go straight to the legacy per-text path (one probe per
+  // old ollama install, not one probe per batch).
+  batchEndpointUnavailable = false;
   constructor(credentials, modelInfo) {
     super(credentials, modelInfo);
   }
@@ -3059,6 +3029,21 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
     const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
     return message.includes("context length") && (message.includes("exceed") || message.includes("exceeded") || message.includes("too long")) || message.includes("input length exceeds the context length") || message.includes("context length exceeded");
   }
+  // True for a 404 from the newer /api/embed endpoint, i.e. an ollama version that
+  // does not provide it. embedBatch uses this to fall back to the legacy per-text
+  // /api/embeddings path so old ollama installs do not regress.
+  isBatchEndpointUnavailableError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("Ollama /api/embed not available");
+  }
+  // True for a malformed /api/embed response (wrong vector count or a bad vector).
+  // embedBatch falls back to the per-text path on this so a bad batch response
+  // re-embeds each text cleanly. A text that then fails per-text is not isolated
+  // here; it is isolated on the recovery run, which re-embeds one text per request.
+  isBatchValidationError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("invalid embedding batch");
+  }
   buildTruncationCandidates(text) {
     const baseMaxChars = Math.max(1, this.modelInfo.maxTokens * 4);
     const candidateLimits = /* @__PURE__ */ new Set();
@@ -3160,7 +3145,74 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
       tokensUsed: this.estimateTokens(text)
     };
   }
-  async embedBatch(texts) {
+  // Embeds many texts in one POST /api/embed request (input: string[]). Ollama
+  // encodes each input independently, so the model context length applies per input
+  // (the upstream splitter already bounds each input), not over the batch. This
+  // amortizes N HTTP round-trips into one.
+  async embedMany(texts) {
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      _OllamaEmbeddingProvider.REQUEST_TIMEOUT_MS
+    );
+    let response;
+    try {
+      response = await fetch(`${this.credentials.baseUrl}/api/embed`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: this.modelInfo.model,
+          input: texts,
+          truncate: false
+        }),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(
+          `Ollama embedding request timed out after ${_OllamaEmbeddingProvider.REQUEST_TIMEOUT_MS}ms`
+        );
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (!response.ok) {
+      const error = (await response.text()).slice(0, 500);
+      if (response.status === 404) {
+        throw new Error(`Ollama /api/embed not available: ${response.status} - ${error}`);
+      }
+      throw new Error(`Ollama embedding API error: ${response.status} - ${error}`);
+    }
+    let parsed;
+    try {
+      parsed = await response.json();
+    } catch {
+      throw new Error(
+        `Ollama returned an invalid embedding batch; expected ${texts.length} vectors of ${this.modelInfo.dimensions} finite dimensions`
+      );
+    }
+    const data = parsed && typeof parsed === "object" ? parsed : {};
+    if (!Array.isArray(data.embeddings) || data.embeddings.length !== texts.length || data.embeddings.some(
+      (value) => !Array.isArray(value) || value.length !== this.modelInfo.dimensions || value.some((v) => typeof v !== "number" || !Number.isFinite(v))
+    )) {
+      throw new Error(
+        `Ollama returned an invalid embedding batch; expected ${texts.length} vectors of ${this.modelInfo.dimensions} finite dimensions`
+      );
+    }
+    return {
+      embeddings: data.embeddings,
+      totalTokensUsed: texts.reduce((sum, text) => sum + this.estimateTokens(text), 0)
+    };
+  }
+  // Per-text /api/embeddings path shared by the single-text fast path and the
+  // batch fallback. Uses the legacy endpoint one text at a time, so each text gets
+  // its own truncation safety net and a vector validated on its own. A text that
+  // hard-fails per-text throws here and fails the whole request batch; the recovery
+  // run re-embeds one text per request to isolate it.
+  async embedOneByOne(texts) {
     const results = [];
     for (const text of texts) {
       results.push(await this.embedSingleWithFallback(text));
@@ -3170,6 +3222,26 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
       totalTokensUsed: results.reduce((sum, r) => sum + r.tokensUsed, 0)
     };
   }
+  async embedBatch(texts) {
+    if (texts.length === 0) {
+      return { embeddings: [], totalTokensUsed: 0 };
+    }
+    if (texts.length === 1 || this.batchEndpointUnavailable) {
+      return this.embedOneByOne(texts);
+    }
+    try {
+      return await this.embedMany(texts);
+    } catch (error) {
+      if (this.isBatchEndpointUnavailableError(error)) {
+        this.batchEndpointUnavailable = true;
+        return this.embedOneByOne(texts);
+      }
+      if (!this.isContextLengthError(error) && !this.isBatchValidationError(error)) {
+        throw error;
+      }
+      return this.embedOneByOne(texts);
+    }
+  }
 };
 
 // src/embeddings/providers/openai.ts
@@ -3204,8 +3276,6 @@ var OpenAIEmbeddingProvider = class extends BaseEmbeddingProvider {
 // src/embeddings/provider.ts
 function createEmbeddingProvider(configuredProviderInfo) {
   switch (configuredProviderInfo.provider) {
-    case "github-copilot":
-      return new GitHubCopilotEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
     case "openai":
       return new OpenAIEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
     case "google":
@@ -3221,85 +3291,6 @@ function createEmbeddingProvider(configuredProviderInfo) {
   }
 }
 
-// src/rerank/index.ts
-function createReranker(config) {
-  if (!config.enabled) {
-    return new NoOpReranker();
-  }
-  return new SiliconFlowReranker(config);
-}
-var NoOpReranker = class {
-  isAvailable() {
-    return false;
-  }
-  async rerank(_query, documents, _topN) {
-    return {
-      results: documents.map((_, index) => ({ index, relevanceScore: 0 }))
-    };
-  }
-};
-var SiliconFlowReranker = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  isAvailable() {
-    return this.config.enabled && !!this.config.baseUrl && !!this.config.model;
-  }
-  async rerank(query, documents, topN) {
-    if (documents.length === 0) {
-      return { results: [] };
-    }
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.config.apiKey) {
-      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
-    }
-    const baseUrl = this.config.baseUrl;
-    if (!baseUrl) {
-      throw new Error("Reranker baseUrl is required. Configure reranker.baseUrl in your codebase-index.json.");
-    }
-    const timeoutMs = this.config.timeoutMs ?? 3e4;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      const response = await fetch(`${baseUrl}/rerank`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          model: this.config.model,
-          query,
-          documents,
-          top_n: topN ?? this.config.topN ?? 20,
-          return_documents: false
-        }),
-        signal: controller.signal
-      });
-      clearTimeout(timeout);
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Rerank API error: ${response.status} - ${errorText}`);
-      }
-      const data = await response.json();
-      return {
-        results: data.results.map((r) => ({
-          index: r.index,
-          relevanceScore: r.relevance_score,
-          document: r.document?.text
-        })),
-        tokensUsed: data.meta?.tokens?.input_tokens
-      };
-    } catch (error) {
-      clearTimeout(timeout);
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Rerank API request timed out after ${timeoutMs}ms`);
-      }
-      throw error;
-    }
-  }
-};
-
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
 var import_fs3 = require("fs");
@@ -3461,8 +3452,8 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     if (entry.isDirectory()) {
       subdirs.push({ fullPath, relativePath });
     } else if (entry.isFile()) {
-      const stat4 = await import_fs3.promises.stat(fullPath);
-      if (stat4.size > maxFileSize) {
+      const stat5 = await import_fs3.promises.stat(fullPath);
+      if (stat5.size > maxFileSize) {
         skipped.push({ path: relativePath, reason: "too_large" });
         continue;
       }
@@ -3480,7 +3471,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
         }
       }
       if (matched) {
-        filesInDir.push({ path: fullPath, size: stat4.size });
+        filesInDir.push({ path: fullPath, size: stat5.size });
       }
     }
   }
@@ -3537,8 +3528,8 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
     }
     for (const resolvedKbRoot of normalizedRoots) {
       try {
-        const stat4 = await import_fs3.promises.stat(resolvedKbRoot);
-        if (!stat4.isDirectory()) {
+        const stat5 = await import_fs3.promises.stat(resolvedKbRoot);
+        if (!stat5.isDirectory()) {
           skipped.push({ path: resolvedKbRoot, reason: "excluded" });
           continue;
         }
@@ -4303,12 +4294,12 @@ try {
 }
 
 // src/native/parsing.ts
-function parseFileAsText(filePath, content) {
-  const result = native.parseFileAsText(filePath, content);
+function parseFileAsText(filePath, content, linesPerChunk) {
+  const result = native.parseFileAsText(filePath, content, linesPerChunk);
   return result.map(mapChunk);
 }
-function parseFiles(files) {
-  const result = native.parseFiles(files);
+function parseFiles(files, linesPerChunk) {
+  const result = native.parseFiles(files, linesPerChunk);
   return result.map((f) => ({
     path: f.path,
     chunks: f.chunks.map(mapChunk),
@@ -4385,13 +4376,13 @@ var VectorStore = class {
     const metadata = items.map((i) => JSON.stringify(i.metadata));
     this.inner.addBatch(ids, vectors, metadata);
   }
-  search(queryVector, limit = 10) {
+  search(queryVector, limit = 10, allowedIds) {
     if (queryVector.length !== this.dimensions) {
       throw new Error(
         `Query vector dimension mismatch: expected ${this.dimensions}, got ${queryVector.length}`
       );
     }
-    const results = this.inner.search(queryVector, limit);
+    const results = allowedIds === void 0 ? this.inner.search(queryVector, limit) : this.inner.searchFiltered(queryVector, limit, allowedIds);
     return results.map((r) => ({
       id: r.id,
       score: r.score,
@@ -4619,6 +4610,10 @@ var Database = class _Database {
     this.throwIfClosed();
     return this.inner.getBranchChunkIds(branch);
   }
+  getChunkIdsByBlameDate(since, until) {
+    this.throwIfClosed();
+    return this.inner.getChunkIdsByBlameDate(since, until);
+  }
   getBranchDelta(branch, baseBranch) {
     this.throwIfClosed();
     return this.inner.getBranchDelta(branch, baseBranch);
@@ -4865,11 +4860,11 @@ function resolveGitDir(repoRoot) {
     return null;
   }
   try {
-    const stat4 = (0, import_fs5.statSync)(gitPath);
-    if (stat4.isDirectory()) {
+    const stat5 = (0, import_fs5.statSync)(gitPath);
+    if (stat5.isDirectory()) {
       return gitPath;
     }
-    if (stat4.isFile()) {
+    if (stat5.isFile()) {
       const content = (0, import_fs5.readFileSync)(gitPath, "utf-8").trim();
       const match = content.match(/^gitdir:\s*(.+)$/);
       if (match) {
@@ -5374,8 +5369,8 @@ async function isWorktreeRegistered(projectRoot, worktreePath) {
   return false;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const relative12 = path9.relative(path9.resolve(rootPath), path9.resolve(filePath));
-  return relative12 === "" || !relative12.startsWith(`..${path9.sep}`) && relative12 !== ".." && !path9.isAbsolute(relative12);
+  const relative14 = path9.relative(path9.resolve(rootPath), path9.resolve(filePath));
+  return relative14 === "" || !relative14.startsWith(`..${path9.sep}`) && relative14 !== ".." && !path9.isAbsolute(relative14);
 }
 async function pruneExactMissingWorktreeRegistration(projectRoot, worktreePath) {
   if (await pathExists(worktreePath)) return false;
@@ -5580,6 +5575,9 @@ function resolveWorktreeFallbackPath(projectRoot, relativePath) {
   const fallbackPath = path10.join(mainRepoRoot, relativePath);
   return (0, import_fs7.existsSync)(fallbackPath) ? fallbackPath : null;
 }
+function getHostProjectConfigRelativePath(host) {
+  return getProjectConfigRelativePath(host);
+}
 function getProjectConfigCandidatePaths(projectRoot, host) {
   const candidates = [path10.join(projectRoot, getProjectConfigRelativePath(host))];
   if (host !== "opencode") {
@@ -5671,6 +5669,9 @@ function resolveProjectConfigPath(projectRoot, host) {
   const candidates = getProjectConfigCandidatePaths(projectRoot, host);
   return candidates.find((candidate) => (0, import_fs7.existsSync)(candidate)) ?? path10.join(projectRoot, getProjectConfigRelativePath(host));
 }
+function resolveWritableProjectConfigPath(projectRoot, host) {
+  return path10.join(projectRoot, getProjectConfigRelativePath(host));
+}
 function resolveProjectIndexPath(projectRoot, scope, host) {
   if (scope === "global") {
     return resolveGlobalIndexPath(host);
@@ -5933,11 +5934,11 @@ function normalizeFiles(rawFiles, projectRoot) {
   for (const raw of rawFiles) {
     if (raw.length === 0) continue;
     const absolute = path11.resolve(root, raw);
-    const relative12 = path11.relative(root, absolute);
-    if (path11.isAbsolute(raw) || relative12 === ".." || relative12.startsWith(`..${path11.sep}`) || path11.isAbsolute(relative12)) {
+    const relative14 = path11.relative(root, absolute);
+    if (path11.isAbsolute(raw) || relative14 === ".." || relative14.startsWith(`..${path11.sep}`) || path11.isAbsolute(relative14)) {
       throw new Error(`Changed file escapes the project root: ${JSON.stringify(raw)}`);
     }
-    const cleaned = relative12.startsWith(`.${path11.sep}`) ? relative12.slice(2) : relative12;
+    const cleaned = relative14.startsWith(`.${path11.sep}`) ? relative14.slice(2) : relative14;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
       result.push(cleaned);
@@ -6274,7 +6275,7 @@ function analyzeQueryIntent(query) {
 }
 function isTestPath(filePath) {
   const normalized = normalizePath(filePath);
-  return /(?:^|\/)(?:test|tests|__tests__|spec|specs)(?:\/|$)/u.test(normalized) || /\.(?:test|spec)\.[^/]+$/u.test(normalized);
+  return /(?:^|\/)(?:test|tests|__tests__|spec|specs)(?:\/|$)/u.test(normalized) || /(?:\.(?:test|spec)|_(?:test|spec))\.[^/]+$/u.test(normalized) || /(?:^|\/)(?:test|spec)_[^/]+\.[^/]+$/u.test(normalized);
 }
 function isFixturePath(filePath) {
   const normalized = normalizePath(filePath);
@@ -6376,6 +6377,10 @@ function scoreCandidate(query, intent, candidate, originalIndex) {
   let boost = 0;
   if (intent.primary === "conceptual") {
     boost += Math.min(0.14, overlap * 0.14);
+    if (intent.preferSourcePaths) {
+      boost += implementationPath ? 0.32 : 0;
+      if (testPath || fixturePath || docsPath) boost -= 0.35;
+    }
     if (generatedOrVendor) boost -= 0.18;
     if (importChunk || weakContainer) boost -= 0.04;
   } else if (intent.primary === "test") {
@@ -6681,7 +6686,8 @@ function rankHybridResults(query, semanticResults, keywordResults, options) {
       return cached;
     }
   }
-  const overfetchLimit = Math.max(options.limit * 4, options.limit);
+  const overfetchFactor = prioritizeSourcePaths ? 12 : 4;
+  const overfetchLimit = Math.max(options.limit * overfetchFactor, options.limit);
   const fused = options.fusionStrategy === "rrf" ? fuseResultsRrf(semanticResults, keywordResults, options.rrfK, overfetchLimit) : fuseResultsWeighted(semanticResults, keywordResults, options.hybridWeight, overfetchLimit);
   const rerankPoolLimit = Math.max(overfetchLimit, options.rerankTopN * 3, options.limit * 6);
   const rerankPool = fused.slice(0, rerankPoolLimit);
@@ -7289,6 +7295,19 @@ function parseOwner(value) {
   if (typeof candidate.startedAt !== "string" || Number.isNaN(Date.parse(candidate.startedAt))) return null;
   if (typeof candidate.operation !== "string" || !VALID_OPERATIONS.has(candidate.operation)) return null;
   if (typeof candidate.token !== "string" || !UUID_PATTERN.test(candidate.token)) return null;
+  if (candidate.recoveryProtocolVersion !== void 0 && candidate.recoveryProtocolVersion !== 1) return null;
+  if (candidate.projectRoot !== void 0 && typeof candidate.projectRoot !== "string") return null;
+  if (candidate.scopedRoots !== void 0) {
+    if (!Array.isArray(candidate.scopedRoots) || candidate.scopedRoots.some((root) => typeof root !== "string")) {
+      return null;
+    }
+  }
+  if (candidate.clearRecovery !== void 0) {
+    const recovery = candidate.clearRecovery;
+    if (typeof recovery !== "object" || recovery === null || recovery.phase !== "clearing" || typeof recovery.embeddingProvider !== "string" || recovery.embeddingProvider.length === 0 || typeof recovery.embeddingModel !== "string" || recovery.embeddingModel.length === 0 || !Number.isInteger(recovery.embeddingDimensions) || (recovery.embeddingDimensions ?? 0) <= 0 || typeof recovery.embeddingStrategyVersion !== "string" || recovery.embeddingStrategyVersion.length === 0 || recovery.compatibilityDecision !== "compatible" && recovery.compatibilityDecision !== "embedding-strategy-mismatch" && recovery.compatibilityDecision !== "incompatible" || candidate.operation !== "clear" && candidate.operation !== "force-index") {
+      return null;
+    }
+  }
   return candidate;
 }
 function parseReclaimOwner(value) {
@@ -7529,13 +7548,18 @@ function isTransientIndexLockContention(error) {
   if (!isIndexLockContentionError(error) || !("reason" in error)) return false;
   return error.reason === "active" || error.reason === "reclaiming";
 }
-function acquireIndexLock(indexPath, operation) {
+function acquireIndexLock(indexPath, operation, recoveryScope) {
   (0, import_fs9.mkdirSync)(indexPath, { recursive: true });
   const canonicalIndexPath = import_fs9.realpathSync.native(indexPath);
   const lockPath = path13.join(canonicalIndexPath, "indexing.lock");
   cleanupDeadPublicationCandidates(canonicalIndexPath);
   for (let attempt = 0; attempt < 6; attempt += 1) {
-    const owner = createOwner(operation);
+    const owner = recoveryScope === void 0 ? createOwner(operation) : {
+      ...createOwner(operation),
+      recoveryProtocolVersion: 1,
+      projectRoot: recoveryScope.projectRoot,
+      scopedRoots: recoveryScope.scopedRoots
+    };
     if (publishJsonDirectory(lockPath, owner)) {
       const lease = {
         canonicalIndexPath,
@@ -7600,6 +7624,33 @@ function releaseIndexLock(lease) {
   }
   return true;
 }
+function setIndexLockClearRecoveryState(lease, clearRecovery) {
+  const currentOwner = readDirectoryOwner(lease.lockPath);
+  if (!currentOwner || !sameOwner(currentOwner, lease.owner)) {
+    throw new Error(`Lost ownership of index mutation lease ${lease.owner.token}`);
+  }
+  const nextOwner = { ...currentOwner };
+  if (clearRecovery === null) {
+    delete nextOwner.clearRecovery;
+  } else {
+    nextOwner.clearRecovery = clearRecovery;
+  }
+  const ownerPath = path13.join(lease.lockPath, OWNER_FILE_NAME);
+  const temporaryPath = path13.join(
+    lease.lockPath,
+    `${OWNER_FILE_NAME}.tmp.${lease.owner.pid}.${lease.owner.token}.${(0, import_crypto2.randomUUID)()}`
+  );
+  try {
+    (0, import_fs9.writeFileSync)(temporaryPath, JSON.stringify(nextOwner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    retryTransientFilesystemOperation(() => (0, import_fs9.renameSync)(temporaryPath, ownerPath));
+  } finally {
+    if ((0, import_fs9.existsSync)(temporaryPath)) (0, import_fs9.rmSync)(temporaryPath, { force: true });
+  }
+}
 function createLeaseTemporaryPath(targetPath, owner, kind = "tmp") {
   if (kind === "bak") return `${targetPath}.bak.${owner.pid}.${owner.token}`;
   temporaryCounter += 1;
@@ -7837,6 +7888,18 @@ function createFailedBatchWriter(targetPath) {
     temporaryPath
   };
 }
+function writeFailedBatchRecords(targetPath, records) {
+  const writer = createFailedBatchWriter(targetPath);
+  try {
+    for (const record of records) {
+      writer.write(record);
+    }
+    writer.commit();
+  } catch (error) {
+    writer.cleanup();
+    throw error;
+  }
+}
 function* readLegacyFailedBatchRecords(filePath, options) {
   const rawData = fs2.readFileSync(filePath, "utf-8");
   const trimmed = stripLeadingBomAndWhitespace(rawData).trim();
@@ -8119,14 +8182,18 @@ function getSafeEmbeddingChunkTokenLimit(provider) {
   const maxChunkTokens = Math.max(256, Math.floor(providerMaxTokens * 0.75));
   return Math.min(2e3, maxChunkTokens);
 }
-function getDynamicBatchOptions(provider) {
-  if (provider.provider === "ollama") {
-    return {
-      maxBatchTokens: provider.modelInfo.maxTokens,
-      maxBatchItems: 1
-    };
+var DEFAULT_OLLAMA_MAX_BATCH_ITEMS = 16;
+var DEFAULT_OLLAMA_MAX_BATCH_TOKENS = 65536;
+function getDynamicBatchOptions(provider, embeddingBatch) {
+  if (provider.provider !== "ollama") {
+    return {};
   }
-  return {};
+  const base = { maxBatchTokens: DEFAULT_OLLAMA_MAX_BATCH_TOKENS, maxBatchItems: DEFAULT_OLLAMA_MAX_BATCH_ITEMS };
+  return {
+    ...base,
+    ...typeof embeddingBatch?.maxBatchTokens === "number" && Number.isFinite(embeddingBatch.maxBatchTokens) ? { maxBatchTokens: embeddingBatch.maxBatchTokens } : {},
+    ...typeof embeddingBatch?.maxBatchItems === "number" && Number.isFinite(embeddingBatch.maxBatchItems) ? { maxBatchItems: embeddingBatch.maxBatchItems } : {}
+  };
 }
 function isSqliteCorruptionError(error) {
   const message = getErrorMessage3(error).toLowerCase();
@@ -8144,6 +8211,14 @@ function getPendingChunkId(rawChunk) {
   const id = rawChunk.id;
   return typeof id === "string" ? id : null;
 }
+function parseBlameTimestamp(value, endOfDay) {
+  let timestampMs = Date.parse(value);
+  if (Number.isNaN(timestampMs)) return null;
+  if (endOfDay && /^\d{4}-\d{2}-\d{2}$/.test(value.trim())) {
+    timestampMs += 24 * 60 * 60 * 1e3 - 1;
+  }
+  return Math.floor(timestampMs / 1e3);
+}
 function metadataFromBlame(blame) {
   if (!blame) {
     return {};
@@ -8290,7 +8365,7 @@ function promoteIdentifierMatches(query, combined, semanticCandidates, keywordCa
   const remainder = combined.filter((candidate) => !promotedIds.has(candidate.id));
   return [...promoted, ...remainder];
 }
-function buildSymbolDefinitionLane(query, database, branchChunkIds, branchSymbolIds, limit, fallbackCandidates, prioritizeSourcePaths = classifyQueryIntentRaw(query) === "source") {
+function buildSymbolDefinitionLane(query, database, branchChunkIds, branchSymbolIds, limit, fallbackCandidates, prioritizeSourcePaths = classifyQueryIntentRaw(query) === "source", allowNonSourcePaths = false) {
   if (!prioritizeSourcePaths) {
     return [];
   }
@@ -8310,7 +8385,7 @@ function buildSymbolDefinitionLane(query, database, branchChunkIds, branchSymbol
     if (!isImplementationChunkType(chunkType)) {
       return false;
     }
-    if (!isLikelyImplementationPath2(chunk.filePath)) {
+    if (!allowNonSourcePaths && !isLikelyImplementationPath2(chunk.filePath)) {
       return false;
     }
     const nameLower = (chunk.name ?? "").toLowerCase();
@@ -8374,7 +8449,7 @@ function buildSymbolDefinitionLane(query, database, branchChunkIds, branchSymbol
         }
         foundCoveringChunk = upsertChunkCandidate(chunk, identifier, normalizedIdentifier) || foundCoveringChunk;
       }
-      if (foundCoveringChunk || !isLikelyImplementationPath2(symbol.filePath)) {
+      if (foundCoveringChunk || !allowNonSourcePaths && !isLikelyImplementationPath2(symbol.filePath)) {
         continue;
       }
       const symbolName = symbol.name.toLowerCase();
@@ -8428,7 +8503,7 @@ function buildSymbolDefinitionLane(query, database, branchChunkIds, branchSymbol
   const ranked = Array.from(symbolCandidates.values()).sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
   if (ranked.length === 0) {
     const implementationFallback = fallbackCandidates.filter(
-      (candidate) => isImplementationChunkType(candidate.metadata.chunkType) && isLikelyImplementationPath2(candidate.metadata.filePath)
+      (candidate) => isImplementationChunkType(candidate.metadata.chunkType) && (allowNonSourcePaths || isLikelyImplementationPath2(candidate.metadata.filePath))
     );
     for (const candidate of implementationFallback) {
       const nameLower = (candidate.metadata.name ?? "").toLowerCase();
@@ -8544,10 +8619,16 @@ function matchesHardSearchFilters(candidate, options, projectRoot) {
     return false;
   }
   if (options?.blameSince) {
-    const sinceMs = Date.parse(options.blameSince);
-    if (Number.isNaN(sinceMs)) return false;
+    const since = parseBlameTimestamp(options.blameSince, false);
+    if (since === null) return false;
     const committedAt = candidate.metadata.blameCommittedAt;
-    if (committedAt === void 0 || committedAt < Math.floor(sinceMs / 1e3)) return false;
+    if (committedAt === void 0 || committedAt < since) return false;
+  }
+  if (options?.blameUntil) {
+    const until = parseBlameTimestamp(options.blameUntil, true);
+    if (until === null) return false;
+    const committedAt = candidate.metadata.blameCommittedAt;
+    if (committedAt === void 0 || committedAt > until) return false;
   }
   return true;
 }
@@ -8583,7 +8664,6 @@ var Indexer = class _Indexer {
   database = null;
   provider = null;
   configuredProviderInfo = null;
-  reranker = null;
   fileHashCache = /* @__PURE__ */ new Map();
   fileHashCachePath = "";
   failedBatchesPath = "";
@@ -8604,9 +8684,10 @@ var Indexer = class _Indexer {
   writerArtifactFingerprint = null;
   readerArtifactRetryAfter = /* @__PURE__ */ new Map();
   fileBatchLimits;
+  checkpointIntervalChunks;
   constructor(projectRoot, config, host, runtimeOptions = {}) {
     this.projectRoot = projectRoot;
-    this.projectIdentityHash = hashContent(this.getCanonicalPath(projectRoot)).slice(0, 16);
+    this.projectIdentityHash = this.getProjectIdentityHash(projectRoot);
     this.materializedProjectRoot = runtimeOptions.materializedProjectRoot ?? projectRoot;
     this.branchNameOverride = runtimeOptions.branchName;
     this.catalogIdentityOverride = runtimeOptions.catalogIdentity;
@@ -8616,6 +8697,7 @@ var Indexer = class _Indexer {
     this.expectedCommitOverride = runtimeOptions.expectedCommit?.toLowerCase();
     this.indexPathOverride = runtimeOptions.indexPath;
     this.fileBatchLimits = runtimeOptions.fileBatchLimits;
+    this.checkpointIntervalChunks = runtimeOptions.checkpointIntervalChunks;
     this.config = config;
     this.host = host;
     if (isGitRepo(this.materializedProjectRoot)) {
@@ -8727,6 +8809,9 @@ var Indexer = class _Indexer {
       return path15.resolve(targetPath);
     }
   }
+  getProjectIdentityHash(projectRoot) {
+    return hashContent(this.getCanonicalPath(projectRoot)).slice(0, 16);
+  }
   isProjectOwnedIndexPath() {
     return isProjectIndexPathOwnedByProject(this.projectRoot, this.indexPath, this.host);
   }
@@ -8743,7 +8828,6 @@ var Indexer = class _Indexer {
     this.database = null;
     this.provider = null;
     this.configuredProviderInfo = null;
-    this.reranker = null;
     this.indexCompatibility = null;
     this.initializationMode = "none";
     this.readIssues = [];
@@ -8764,7 +8848,10 @@ var Indexer = class _Indexer {
   }
   async withIndexMutationLease(operation, callback) {
     this.refreshBranchInfo();
-    const lease = acquireIndexLock(this.indexPath, operation);
+    const lease = acquireIndexLock(this.indexPath, operation, {
+      projectRoot: this.projectRoot,
+      scopedRoots: this.getScopedRoots()
+    });
     this.indexPath = lease.canonicalIndexPath;
     this.refreshRuntimeArtifactPaths();
     this.activeIndexLease = lease;
@@ -8819,6 +8906,7 @@ var Indexer = class _Indexer {
   }
   loadFileHashCache() {
     if (!(0, import_fs10.existsSync)(this.fileHashCachePath)) {
+      this.fileHashCache = /* @__PURE__ */ new Map();
       return;
     }
     try {
@@ -8858,10 +8946,10 @@ var Indexer = class _Indexer {
       invertedIndex.serialize()
     );
   }
-  getScopedRoots() {
-    const roots = /* @__PURE__ */ new Set([this.getCanonicalPath(this.projectRoot)]);
+  getScopedRoots(projectRoot = this.projectRoot) {
+    const roots = /* @__PURE__ */ new Set([this.getCanonicalPath(projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(this.getCanonicalPath(path15.resolve(this.projectRoot, kbRoot)));
+      roots.add(this.getCanonicalPath(path15.resolve(projectRoot, kbRoot)));
     }
     return Array.from(roots);
   }
@@ -8932,14 +9020,17 @@ var Indexer = class _Indexer {
   getLegacyBranchCatalogKey() {
     return this.currentBranch || "default";
   }
-  getLegacyMigrationMetadataKey() {
-    return `index.globalBranchMigration.${this.projectIdentityHash}`;
+  getLegacyMigrationMetadataKey(projectIdentityHash = this.projectIdentityHash) {
+    return `index.globalBranchMigration.${projectIdentityHash}`;
   }
-  getProjectEmbeddingStrategyMetadataKey() {
-    return `index.embeddingStrategyVersion.${this.projectIdentityHash}`;
+  getProjectEmbeddingStrategyMetadataKey(projectIdentityHash = this.projectIdentityHash) {
+    return `index.embeddingStrategyVersion.${projectIdentityHash}`;
   }
-  getProjectForceReembedMetadataKey() {
-    return `index.forceReembed.${this.projectIdentityHash}`;
+  getProjectForceReembedMetadataKey(projectIdentityHash = this.projectIdentityHash) {
+    return `index.forceReembed.${projectIdentityHash}`;
+  }
+  getProjectMigrationFinalizedMetadataKey(projectIdentityHash = this.projectIdentityHash) {
+    return `index.migrationFinalized.${projectIdentityHash}`;
   }
   getBranchMigrationMetadataKey(prefix, catalogIdentity = this.getBranchCatalogIdentity()) {
     const branchKey = this.getBranchCatalogKeyFor(catalogIdentity);
@@ -9045,7 +9136,7 @@ var Indexer = class _Indexer {
     const legacy = this.getLegacyBranchCatalogKey();
     return primary === legacy ? [primary] : [primary, legacy];
   }
-  getProjectLocalScopedOwnershipIds(roots) {
+  getProjectLocalScopedOwnershipIds(roots, projectRoot = this.projectRoot) {
     const chunkIds = /* @__PURE__ */ new Set();
     const symbolIds = /* @__PURE__ */ new Set();
     if (!this.database) {
@@ -9053,10 +9144,10 @@ var Indexer = class _Indexer {
     }
     const projectLocalFilePaths = /* @__PURE__ */ new Set([
       ...Array.from(this.fileHashCache.keys()).filter(
-        (filePath) => this.isFileInCurrentScope(filePath, roots) && this.isFileInProjectRoot(filePath)
+        (filePath) => this.isFileInCurrentScope(filePath, roots) && this.isFileInProjectRoot(filePath, projectRoot)
       ),
       ...(this.store?.getAllMetadata() ?? []).map(({ metadata }) => metadata.filePath).filter(
-        (filePath) => this.isFileInCurrentScope(filePath, roots) && this.isFileInProjectRoot(filePath)
+        (filePath) => this.isFileInCurrentScope(filePath, roots) && this.isFileInProjectRoot(filePath, projectRoot)
       )
     ]);
     for (const filePath of projectLocalFilePaths) {
@@ -9069,15 +9160,16 @@ var Indexer = class _Indexer {
     }
     return { chunkIds, symbolIds };
   }
-  getProjectScopedBranchCatalogCleanupKeys(projectChunkIds, projectSymbolIds) {
+  getProjectScopedBranchCatalogCleanupKeys(projectChunkIds, projectSymbolIds, projectRoot = this.projectRoot) {
     if (this.config.scope !== "global") {
       return this.getBranchCatalogCleanupKeys();
     }
     const keys = /* @__PURE__ */ new Set();
     const projectChunkIdSet = new Set(projectChunkIds);
     const projectSymbolIdSet = new Set(projectSymbolIds);
+    const projectIdentityHash = this.getProjectIdentityHash(projectRoot);
     for (const branchKey of this.database?.getAllBranches() ?? []) {
-      if (branchKey.startsWith(`${this.projectIdentityHash}:`)) {
+      if (branchKey.startsWith(`${projectIdentityHash}:`)) {
         keys.add(branchKey);
         continue;
       }
@@ -9087,8 +9179,10 @@ var Indexer = class _Indexer {
         keys.add(branchKey);
       }
     }
-    for (const branchKey of this.getBranchCatalogCleanupKeys()) {
-      keys.add(branchKey);
+    if (projectRoot === this.projectRoot) {
+      for (const branchKey of this.getBranchCatalogCleanupKeys()) {
+        keys.add(branchKey);
+      }
     }
     return Array.from(keys);
   }
@@ -9096,10 +9190,10 @@ var Indexer = class _Indexer {
     const canonicalFilePath = this.getCanonicalStoredFilePath(filePath);
     return roots.some((root) => isPathWithinRoot2(canonicalFilePath, root));
   }
-  isFileInProjectRoot(filePath) {
+  isFileInProjectRoot(filePath, projectRoot = this.projectRoot) {
     return isPathWithinRoot2(
       this.getCanonicalStoredFilePath(filePath),
-      this.getCanonicalPath(this.projectRoot)
+      this.getCanonicalPath(projectRoot)
     );
   }
   clearScopedFileHashCache(roots) {
@@ -9141,12 +9235,12 @@ var Indexer = class _Indexer {
     }
     return false;
   }
-  hasForeignScopedBranchData() {
+  hasForeignScopedBranchData(projectRoot = this.projectRoot, roots = this.getScopedRoots(projectRoot)) {
     if (!this.database || this.config.scope !== "global") {
       return false;
     }
-    const roots = this.getScopedRoots();
-    const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots);
+    const projectIdentityHash = this.getProjectIdentityHash(projectRoot);
+    const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots, projectRoot);
     return this.database.getAllBranches().some(
       (branchKey) => {
         const branchChunkIds = this.database.getBranchChunkIds(branchKey);
@@ -9155,7 +9249,7 @@ var Indexer = class _Indexer {
         if (!hasBranchData) {
           return false;
         }
-        if (branchKey.startsWith(`${this.projectIdentityHash}:`)) {
+        if (branchKey.startsWith(`${projectIdentityHash}:`)) {
           return false;
         }
         const referencesCurrentProjectChunks = branchChunkIds.some((chunkId) => projectLocalChunkIds.has(chunkId));
@@ -9164,7 +9258,7 @@ var Indexer = class _Indexer {
       }
     );
   }
-  clearSharedIndexProjectData(store, invertedIndex, database, roots) {
+  clearSharedIndexProjectData(store, invertedIndex, database, roots, projectRoot = this.projectRoot) {
     const allMetadata = store.getAllMetadata();
     const scopedEntries = allMetadata.filter(({ metadata }) => this.isFileInCurrentScope(metadata.filePath, roots));
     const filePaths = /* @__PURE__ */ new Set([
@@ -9172,7 +9266,7 @@ var Indexer = class _Indexer {
       ...scopedEntries.map(({ metadata }) => metadata.filePath)
     ]);
     const projectLocalFilePaths = new Set(
-      Array.from(filePaths).filter((filePath) => this.isFileInProjectRoot(filePath))
+      Array.from(filePaths).filter((filePath) => this.isFileInProjectRoot(filePath, projectRoot))
     );
     const removedChunkIds = new Set(scopedEntries.map(({ key }) => key));
     for (const filePath of filePaths) {
@@ -9182,7 +9276,7 @@ var Indexer = class _Indexer {
     }
     const removedChunkIdList = Array.from(removedChunkIds);
     const projectLocalChunkIds = new Set(
-      scopedEntries.filter(({ metadata }) => this.isFileInProjectRoot(metadata.filePath)).map(({ key }) => key)
+      scopedEntries.filter(({ metadata }) => this.isFileInProjectRoot(metadata.filePath, projectRoot)).map(({ key }) => key)
     );
     for (const filePath of projectLocalFilePaths) {
       for (const chunk of database.getChunksByFile(filePath)) {
@@ -9201,7 +9295,8 @@ var Indexer = class _Indexer {
     }
     const branchCleanupKeys = this.getProjectScopedBranchCatalogCleanupKeys(
       Array.from(projectLocalChunkIds),
-      Array.from(projectLocalSymbolIds)
+      Array.from(projectLocalSymbolIds),
+      projectRoot
     );
     for (const branchKey of branchCleanupKeys) {
       database.deleteBranchChunksForBranch(branchKey, removedChunkIdList);
@@ -9236,29 +9331,96 @@ var Indexer = class _Indexer {
     database.gcOrphanSymbols();
     database.gcOrphanEmbeddings();
     database.gcOrphanChunks();
-    store.save();
     this.saveInvertedIndex(invertedIndex);
+    store.save();
     return {
       removedChunkIds: removedChunkIdList,
       hasForeignData: allMetadata.some(({ metadata }) => !this.isFileInCurrentScope(metadata.filePath, roots))
     };
   }
+  getCurrentClearRecoveryState() {
+    if (!this.configuredProviderInfo) {
+      throw new Error("Cannot persist clear recovery state before the embedding provider is initialized");
+    }
+    const compatibility = this.checkCompatibility();
+    const compatibilityDecision = compatibility.compatible ? "compatible" : compatibility.code === "EMBEDDING_STRATEGY_MISMATCH" /* EMBEDDING_STRATEGY_MISMATCH */ ? "embedding-strategy-mismatch" : "incompatible";
+    return {
+      phase: "clearing",
+      embeddingProvider: this.configuredProviderInfo.provider,
+      embeddingModel: this.configuredProviderInfo.modelInfo.model,
+      embeddingDimensions: this.configuredProviderInfo.modelInfo.dimensions,
+      embeddingStrategyVersion: EMBEDDING_STRATEGY_VERSION,
+      compatibilityDecision
+    };
+  }
+  beginClearRecoveryState() {
+    const recovery = this.getCurrentClearRecoveryState();
+    setIndexLockClearRecoveryState(this.requireActiveLease(), recovery);
+    return recovery;
+  }
+  finishClearRecoveryState() {
+    setIndexLockClearRecoveryState(this.requireActiveLease(), null);
+  }
+  matchesCurrentClearRecoveryConfiguration(recovery) {
+    const configuredProviderInfo = this.configuredProviderInfo;
+    return configuredProviderInfo !== null && recovery.embeddingProvider === configuredProviderInfo.provider && recovery.embeddingModel === configuredProviderInfo.modelInfo.model && recovery.embeddingDimensions === configuredProviderInfo.modelInfo.dimensions && recovery.embeddingStrategyVersion === EMBEDDING_STRATEGY_VERSION;
+  }
+  hasUnknownLegacyForceIndexClear(owner) {
+    return owner.operation === "force-index" && owner.clearRecovery === void 0 && owner.recoveryProtocolVersion !== 1 && (0, import_fs10.existsSync)(path15.join(this.indexPath, "force-index-phase"));
+  }
   async recoverFromInterruptedIndexingUnlocked(owners) {
     for (const owner of owners) {
       this.logger.warn("Detected interrupted indexing session, recovering...", {
         pid: owner.pid,
         hostname: owner.hostname,
         operation: owner.operation,
-        startedAt: owner.startedAt
+        startedAt: owner.startedAt,
+        projectRoot: owner.projectRoot
       });
     }
     if (this.config.scope === "global") {
-      if ((0, import_fs10.existsSync)(this.fileHashCachePath)) {
-        (0, import_fs10.unlinkSync)(this.fileHashCachePath);
+      const clearScopes = [];
+      for (const owner of owners) {
+        if (this.hasUnknownLegacyForceIndexClear(owner)) {
+          throw new Error(
+            `Cannot automatically recover interrupted force-index ${owner.token}: the legacy clearing phase ownership is unknown. The recovery marker was retained for manual inspection.`
+          );
+        }
+        if (owner.operation === "clear" && owner.clearRecovery === void 0 && owner.recoveryProtocolVersion !== 1) {
+          throw new Error(
+            `Cannot automatically recover interrupted global clear ${owner.token}: the originating recovery state is unknown. The recovery marker was retained for manual inspection.`
+          );
+        }
+        if (owner.clearRecovery === void 0) continue;
+        if (!owner.projectRoot || !owner.scopedRoots || owner.scopedRoots.length === 0) {
+          throw new Error(
+            `Cannot automatically recover interrupted global clear ${owner.token}: the originating project scope is unknown. The recovery marker was retained for manual inspection.`
+          );
+        }
+        if (!this.matchesCurrentClearRecoveryConfiguration(owner.clearRecovery)) {
+          throw new Error(
+            `Cannot automatically recover interrupted global clear ${owner.token}: the current embedding configuration does not match the originating lease. The recovery marker was retained; retry from the originating project with matching settings.`
+          );
+        }
+        clearScopes.push({
+          projectRoot: owner.projectRoot,
+          scopedRoots: owner.scopedRoots,
+          compatibilityDecision: owner.clearRecovery.compatibilityDecision
+        });
+      }
+      if (clearScopes.length > 0) {
+        this.loadFileHashCache();
+      }
+      for (const { projectRoot, scopedRoots, compatibilityDecision } of clearScopes) {
+        this.clearGlobalIndexUnlocked(projectRoot, scopedRoots, compatibilityDecision);
       }
       await this.healthCheckUnlocked();
+      this.logger.info(
+        clearScopes.length > 0 ? "Recovery complete, next index will rebuild all files" : "Recovery complete, next index will resume from the last checkpoint"
+      );
+      return;
     }
-    this.logger.info("Recovery complete, next index will re-process all files");
+    this.logger.info("Recovery complete, next index will resume from the last checkpoint");
   }
   *loadSerializedFailedBatches() {
     let warned = false;
@@ -9296,33 +9458,118 @@ var Indexer = class _Indexer {
     state.writer.write(record);
     state.recordsWritten += record.chunks.length;
   }
-  finalizeFailedBatchWriteState(state) {
+  finalizeFailedBatchWriteState(state, resolvedChunkIds = /* @__PURE__ */ new Set()) {
     if (state.recordsWritten > 0) {
-      state.writer.commit();
+      const seenChunkIds = /* @__PURE__ */ new Set();
+      const retained = [];
+      const records = Array.from(readFailedBatchRecords(state.writer.temporaryPath));
+      for (let i = records.length - 1; i >= 0; i--) {
+        const chunks = records[i].chunks.filter((rawChunk) => {
+          const chunkId = getPendingChunkId(rawChunk);
+          if (chunkId !== null) {
+            if (resolvedChunkIds.has(chunkId)) return false;
+            if (seenChunkIds.has(chunkId)) return false;
+            seenChunkIds.add(chunkId);
+          }
+          return true;
+        });
+        if (chunks.length > 0) {
+          retained.unshift({ ...records[i], chunks });
+        }
+      }
+      state.writer.cleanup();
+      if (retained.length > 0) {
+        writeFailedBatchRecords(this.failedBatchesPath, retained);
+      } else {
+        writeFailedBatchRecords(this.failedBatchesPath, []);
+        this.clearFailedBatchState();
+      }
       return;
     }
-    state.writer.cleanup();
+    state.writer.commit();
     this.clearFailedBatchState();
   }
-  clearFailedBatchState() {
-    if ((0, import_fs10.existsSync)(this.failedBatchesPath)) {
-      try {
-        (0, import_fs10.unlinkSync)(this.failedBatchesPath);
-      } catch {
-      }
-    }
+  getCheckpointIntervalChunks(totalChunks) {
+    return Math.max(
+      this.checkpointIntervalChunks ?? 2e3,
+      Math.floor(totalChunks / 10)
+    );
   }
-  rewriteFailedBatchState(shouldRetain) {
-    const state = this.createFailedBatchWriteState();
-    try {
-      for (const batch of this.loadSerializedFailedBatches()) {
-        const retainedChunks = batch.chunks.filter(shouldRetain);
-        if (retainedChunks.length > 0) {
-          this.writeFailedBatchRecord(state, { ...batch, chunks: retainedChunks });
-        }
-      }
-      this.finalizeFailedBatchWriteState(state);
-    } catch (error) {
+  checkpointIndexRun(database, store, invertedIndex, failedProcessing, resolvedRetryChunkIds, currentFileHashes, committedFilePaths, scopedRoots, configuredProviderInfo) {
+    if (!this.hasProjectForceReembedPending()) {
+      this.saveIndexMetadata(configuredProviderInfo);
+      this.indexCompatibility = { compatible: true };
+    }
+    database.commitWriteTransaction();
+    database.beginWriteTransaction();
+    this.saveInvertedIndex(invertedIndex);
+    store.save();
+    if (failedProcessing.state.recordsWritten > 0 || failedProcessing.latestById.size > 0 || failedProcessing.discardedExistingRecords) {
+      for (const metadata of failedProcessing.latestById.values()) {
+        const alreadyMaterialized = metadata.chunks.some((rawChunk) => {
+          const chunkId = getPendingChunkId(rawChunk);
+          return chunkId !== null && failedProcessing.materializedRetryIds.has(chunkId);
+        });
+        if (alreadyMaterialized) continue;
+        this.writeFailedBatchRecord(failedProcessing.state, {
+          chunks: metadata.chunks,
+          attemptCount: metadata.attemptCount,
+          error: metadata.error,
+          lastAttempt: metadata.lastAttempt
+        });
+        for (const rawChunk of metadata.chunks) {
+          const chunkId = getPendingChunkId(rawChunk);
+          if (chunkId !== null) {
+            failedProcessing.materializedRetryIds.add(chunkId);
+          }
+        }
+      }
+      this.finalizeFailedBatchWriteState(failedProcessing.state, resolvedRetryChunkIds);
+      failedProcessing.state = this.createFailedBatchWriteState();
+      failedProcessing.discardedExistingRecords = false;
+      for (const record of this.loadSerializedFailedBatches()) {
+        for (const rawChunk of record.chunks) {
+          const chunkId = getPendingChunkId(rawChunk);
+          this.writeFailedBatchRecord(failedProcessing.state, { ...record, chunks: [rawChunk] });
+          if (chunkId !== null) {
+            failedProcessing.materializedRetryIds.add(chunkId);
+          }
+        }
+      }
+    }
+    const partialHashes = /* @__PURE__ */ new Map();
+    for (const filePath of committedFilePaths) {
+      const hash = currentFileHashes.get(filePath);
+      if (hash !== void 0) {
+        partialHashes.set(filePath, hash);
+      }
+    }
+    if (scopedRoots) {
+      this.replaceScopedFileHashCache(partialHashes, scopedRoots);
+    } else {
+      this.fileHashCache = partialHashes;
+      this.saveFileHashCache();
+    }
+  }
+  clearFailedBatchState() {
+    if ((0, import_fs10.existsSync)(this.failedBatchesPath)) {
+      try {
+        (0, import_fs10.unlinkSync)(this.failedBatchesPath);
+      } catch {
+      }
+    }
+  }
+  rewriteFailedBatchState(shouldRetain) {
+    const state = this.createFailedBatchWriteState();
+    try {
+      for (const batch of this.loadSerializedFailedBatches()) {
+        const retainedChunks = batch.chunks.filter(shouldRetain);
+        if (retainedChunks.length > 0) {
+          this.writeFailedBatchRecord(state, { ...batch, chunks: retainedChunks });
+        }
+      }
+      this.finalizeFailedBatchWriteState(state);
+    } catch (error) {
       state.writer.cleanup();
       throw error;
     }
@@ -9330,6 +9577,7 @@ var Indexer = class _Indexer {
   prepareFailedBatchProcessing(roots, shouldProcess) {
     const state = this.createFailedBatchWriteState();
     const latestById = /* @__PURE__ */ new Map();
+    let discardedExistingRecords = false;
     try {
       for (const batch of this.loadSerializedFailedBatches()) {
         for (const rawChunk of batch.chunks) {
@@ -9340,10 +9588,12 @@ var Indexer = class _Indexer {
             continue;
           }
           if (!shouldProcess(filePath)) {
+            discardedExistingRecords = true;
             continue;
           }
           const chunkId = getPendingChunkId(rawChunk);
           if (!chunkId) {
+            discardedExistingRecords = true;
             continue;
           }
           const existing = latestById.get(chunkId);
@@ -9351,12 +9601,18 @@ var Indexer = class _Indexer {
             latestById.set(chunkId, {
               attemptCount: batch.attemptCount,
               error: batch.error,
-              lastAttempt: batch.lastAttempt
+              lastAttempt: batch.lastAttempt,
+              chunks: [rawChunk]
             });
           }
         }
       }
-      return { state, latestById };
+      return {
+        state,
+        latestById,
+        materializedRetryIds: /* @__PURE__ */ new Set(),
+        discardedExistingRecords
+      };
     } catch (error) {
       state.writer.cleanup();
       throw error;
@@ -9392,10 +9648,34 @@ var Indexer = class _Indexer {
       }
     }
   }
+  restoreMissingChunkRows(database, chunks) {
+    const missing = [];
+    for (const chunk of chunks) {
+      if (database.getChunk(chunk.id)) {
+        continue;
+      }
+      missing.push({
+        chunkId: chunk.id,
+        contentHash: chunk.contentHash,
+        filePath: chunk.metadata.filePath,
+        startLine: chunk.metadata.startLine,
+        endLine: chunk.metadata.endLine,
+        nodeType: chunk.metadata.chunkType,
+        name: chunk.metadata.name,
+        language: chunk.metadata.language,
+        blameSha: chunk.metadata.blameSha,
+        blameAuthor: chunk.metadata.blameAuthor,
+        blameAuthorEmail: chunk.metadata.blameAuthorEmail,
+        blameCommittedAt: chunk.metadata.blameCommittedAt,
+        blameSummary: chunk.metadata.blameSummary
+      });
+    }
+    if (missing.length > 0) {
+      database.upsertChunksBatch(missing);
+    }
+  }
   getProviderRateLimits(provider) {
     switch (provider) {
-      case "github-copilot":
-        return { concurrency: 1, intervalMs: 4e3, minRetryMs: 5e3, maxRetryMs: 6e4 };
       case "openai":
         return { concurrency: 3, intervalMs: 500, minRetryMs: 1e3, maxRetryMs: 3e4 };
       case "google":
@@ -9464,16 +9744,17 @@ var Indexer = class _Indexer {
     const embeddingPartsByChunk = /* @__PURE__ */ new Map();
     const completedVectorsByChunkId = /* @__PURE__ */ new Map();
     const completedChunkIds = /* @__PURE__ */ new Set();
-    const requestBatches = createPendingEmbeddingRequestBatches(
-      chunksNeedingEmbedding,
-      getDynamicBatchOptions(options.configuredProviderInfo)
-    );
+    const batchOptions = getDynamicBatchOptions(options.configuredProviderInfo, this.config.embedding?.batch);
+    if (options.forceSingleItemBatches && options.configuredProviderInfo.provider === "ollama") {
+      batchOptions.maxBatchItems = 1;
+    }
+    const requestBatches = createPendingEmbeddingRequestBatches(chunksNeedingEmbedding, batchOptions);
     let fatalError;
     for (const requestBatch of requestBatches) {
       await options.queue.onSizeLessThan(Math.max(1, options.providerRateLimits.concurrency));
       const task = options.queue.add(async () => {
         if (options.rateLimitState.backoffMs > 0) {
-          await new Promise((resolve18) => setTimeout(resolve18, options.rateLimitState.backoffMs));
+          await new Promise((resolve20) => setTimeout(resolve20, options.rateLimitState.backoffMs));
         }
         try {
           const embeddingResult = await pRetry(
@@ -10030,7 +10311,7 @@ var Indexer = class _Indexer {
     }
     if (!this.configuredProviderInfo) {
       throw new Error(
-        "No embedding provider available. Configure GitHub Copilot, OpenAI, Google, Ollama, or a custom OpenAI-compatible endpoint."
+        "No embedding provider available. Configure OpenAI, Google, Ollama, or a custom OpenAI-compatible endpoint."
       );
     }
     this.logger.info("Initializing indexer", {
@@ -10040,15 +10321,6 @@ var Indexer = class _Indexer {
       rerankerEnabled: this.config.reranker?.enabled ?? false
     });
     this.provider = createEmbeddingProvider(this.configuredProviderInfo);
-    if (this.config.reranker?.enabled) {
-      this.reranker = createReranker(this.config.reranker);
-      if (this.reranker.isAvailable()) {
-        this.logger.info("Reranker initialized", {
-          model: this.config.reranker.model,
-          baseUrl: this.config.reranker.baseUrl
-        });
-      }
-    }
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
     const storePath = path15.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
@@ -10070,7 +10342,20 @@ var Indexer = class _Indexer {
         ]);
       }
       if (recoveredOwners.length > 0 && this.config.scope === "project") {
-        await this.resetLocalIndexArtifacts();
+        const unknownLegacyForceIndex = recoveredOwners.find(
+          (owner) => this.hasUnknownLegacyForceIndexClear(owner)
+        );
+        if (unknownLegacyForceIndex) {
+          throw new Error(
+            `Cannot automatically recover interrupted force-index ${unknownLegacyForceIndex.token}: the legacy clearing phase ownership is unknown. The recovery marker was retained for manual inspection.`
+          );
+        }
+        const shouldReset = recoveredOwners.some(
+          (owner) => owner.clearRecovery !== void 0 || owner.operation === "clear" && owner.recoveryProtocolVersion !== 1
+        );
+        if (shouldReset) {
+          await this.resetLocalIndexArtifacts();
+        }
       }
       this.store = new VectorStore(storePath, dimensions);
       if ((0, import_fs10.existsSync)(storePath) || (0, import_fs10.existsSync)(vectorMetadataPath)) {
@@ -10706,7 +10991,17 @@ var Indexer = class _Indexer {
     const needsCallGraphResolutionMigration = database.getMetadata(this.getCallGraphResolutionMetadataKey()) !== CALL_GRAPH_RESOLUTION_VERSION;
     for (const file of files) {
       const storedPath = this.toStoredFilePath(file.path);
-      const currentHash = hashFile(file.path);
+      let currentHash;
+      try {
+        currentHash = hashFile(file.path);
+      } catch (error) {
+        stats.skippedFiles.push({ path: this.toCanonicalFilePath(file.path), reason: "unreadable" });
+        this.logger.warn("Skipped unreadable file during indexing", {
+          path: file.path,
+          error: getErrorMessage3(error)
+        });
+        continue;
+      }
       currentFileHashes.set(storedPath, currentHash);
       const cachedHashMatches = this.fileHashCache.get(storedPath) === currentHash;
       const needsCallGraphRefresh = cachedHashMatches && needsCallGraphResolutionMigration && database.getChunksByFile(storedPath).some(
@@ -10714,7 +11009,8 @@ var Indexer = class _Indexer {
       );
       const requiresSwiftParserUpgrade = reparseCachedSwiftFiles && path15.extname(storedPath).toLowerCase() === ".swift";
       const requiresMetalParserUpgrade = reparseCachedMetalFiles && path15.extname(storedPath).toLowerCase() === ".metal";
-      if (cachedHashMatches && !needsCallGraphRefresh && !requiresSwiftParserUpgrade && !requiresMetalParserUpgrade && !refreshCachedSymbols) {
+      const inMigrationScope = forceScopedReembed && scopedRoots !== null && this.isFileInCurrentScope(storedPath, scopedRoots);
+      if (cachedHashMatches && !inMigrationScope && !needsCallGraphRefresh && !requiresSwiftParserUpgrade && !requiresMetalParserUpgrade && !refreshCachedSymbols) {
         unchangedFilePaths.add(storedPath);
         this.logger.recordCacheHit();
       } else {
@@ -10840,6 +11136,9 @@ var Indexer = class _Indexer {
         }
       }
       let processedChangedFiles = 0;
+      let lastCheckpointChunks = 0;
+      const committedFilePaths = new Set(unchangedFilePaths);
+      const resolvedRetryChunkIds = /* @__PURE__ */ new Set();
       for (const descriptorBatch of iterateOrderedFileBatches(
         changedFileDescriptors,
         (descriptor) => descriptor.sourceBytes,
@@ -10853,7 +11152,7 @@ var Indexer = class _Indexer {
         const loadedByPath = new Map(loadedFiles.map((file) => [file.path, file]));
         const descriptorByPath = new Map(descriptorBatch.map((descriptor) => [descriptor.storedPath, descriptor]));
         const parseStartTime = import_perf_hooks.performance.now();
-        const parsedFiles = parseFiles(loadedFiles);
+        const parsedFiles = parseFiles(loadedFiles, this.config.indexing.linesPerChunk);
         const parseMs = import_perf_hooks.performance.now() - parseStartTime;
         this.logger.recordFilesParsed(parsedFiles.length);
         this.logger.recordParseDuration(parseMs);
@@ -10876,7 +11175,7 @@ var Indexer = class _Indexer {
           }
           let chunksToProcess = parsed.chunks;
           if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
-            chunksToProcess = parseFileAsText(parsed.path, loadedFile.content);
+            chunksToProcess = parseFileAsText(parsed.path, loadedFile.content, this.config.indexing.linesPerChunk);
           }
           chunksToProcess = selectIndexableChunks(
             chunksToProcess,
@@ -11010,6 +11309,10 @@ var Indexer = class _Indexer {
         }
         if (symbolBatch.length > 0) {
           database.upsertSymbolsBatch(symbolBatch);
+          database.addSymbolsToBranchBatch(
+            this.getBranchCatalogKey(),
+            symbolBatch.map((symbol) => symbol.id)
+          );
         }
         if (edgeBatch.length > 0) {
           database.upsertCallEdgesBatch(edgeBatch);
@@ -11045,6 +11348,12 @@ var Indexer = class _Indexer {
             forceReembed: forceScopedReembed,
             reuseCachedEmbeddings: true,
             incrementRepeatedFailures: true,
+            onSucceeded: (succeededChunks) => {
+              database.addChunksToBranchBatch(
+                this.getBranchCatalogKey(),
+                succeededChunks.map((chunk) => chunk.id)
+              );
+            },
             onProgress: (batchProgress) => onProgress?.({
               phase: "embedding",
               filesProcessed: unchangedFilePaths.size + processedChangedFiles,
@@ -11063,6 +11372,27 @@ var Indexer = class _Indexer {
             }
           }
         }
+        for (const descriptor of descriptorBatch) {
+          const existingFileChunks = existingChunksByFile.get(descriptor.storedPath);
+          if (!existingFileChunks || existingFileChunks.size === 0) {
+            committedFilePaths.add(descriptor.storedPath);
+          }
+        }
+        const checkpointInterval = this.getCheckpointIntervalChunks(stats.totalChunks);
+        if (stats.totalChunks - lastCheckpointChunks >= checkpointInterval) {
+          lastCheckpointChunks = stats.totalChunks;
+          this.checkpointIndexRun(
+            database,
+            store,
+            invertedIndex,
+            failedProcessing,
+            resolvedRetryChunkIds,
+            currentFileHashes,
+            committedFilePaths,
+            scopedRoots,
+            configuredProviderInfo
+          );
+        }
       }
       const retryableFailedChunks = this.iterateLatestFailedChunks(
         failedProcessing.latestById,
@@ -11083,6 +11413,7 @@ var Indexer = class _Indexer {
             retryableChunksWithExistingData.add(chunk.id);
           }
         }
+        this.restoreMissingChunkRows(database, pendingChunks);
         stats.totalChunks += pendingChunks.length;
         onProgress?.({
           phase: "embedding",
@@ -11105,6 +11436,17 @@ var Indexer = class _Indexer {
           forceReembed: forceScopedReembed,
           reuseCachedEmbeddings: true,
           incrementRepeatedFailures: true,
+          forceSingleItemBatches: true,
+          onSucceeded: (succeededChunks) => {
+            database.addChunksToBranchBatch(
+              this.getBranchCatalogKey(),
+              succeededChunks.map((chunk) => chunk.id)
+            );
+            for (const chunk of succeededChunks) {
+              failedProcessing.latestById.delete(chunk.id);
+              resolvedRetryChunkIds.add(chunk.id);
+            }
+          },
           onProgress: (batchProgress) => onProgress?.({
             phase: "embedding",
             filesProcessed: files.length,
@@ -11122,6 +11464,20 @@ var Indexer = class _Indexer {
             failedForcedChunkIds.add(chunkId);
           }
         }
+        if (stats.totalChunks - lastCheckpointChunks >= this.getCheckpointIntervalChunks(stats.totalChunks)) {
+          lastCheckpointChunks = stats.totalChunks;
+          this.checkpointIndexRun(
+            database,
+            store,
+            invertedIndex,
+            failedProcessing,
+            resolvedRetryChunkIds,
+            currentFileHashes,
+            committedFilePaths,
+            scopedRoots,
+            configuredProviderInfo
+          );
+        }
       }
       const removedChunkIds = [];
       for (const [chunkId] of existingChunks) {
@@ -11158,13 +11514,6 @@ var Indexer = class _Indexer {
         if (removedStoredChunks) {
           this.saveInvertedIndex(invertedIndex);
         }
-        if (scopedRoots) {
-          this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
-        } else {
-          this.fileHashCache = currentFileHashes;
-          this.saveFileHashCache();
-        }
-        this.finalizeFailedBatchWriteState(failedProcessing.state);
         database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
         database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
         database.setMetadata(symbolExtractorMetadataKey, SYMBOL_EXTRACTOR_VERSION);
@@ -11173,6 +11522,13 @@ var Indexer = class _Indexer {
         this.indexCompatibility = { compatible: true };
         database.commitWriteTransaction();
         writeTransactionActive = false;
+        this.finalizeFailedBatchWriteState(failedProcessing.state, resolvedRetryChunkIds);
+        if (scopedRoots) {
+          this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
+        } else {
+          this.fileHashCache = currentFileHashes;
+          this.saveFileHashCache();
+        }
         stats.durationMs = Date.now() - startTime;
         onProgress?.({
           phase: "complete",
@@ -11196,13 +11552,6 @@ var Indexer = class _Indexer {
         );
         store.save();
         this.saveInvertedIndex(invertedIndex);
-        if (scopedRoots) {
-          this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
-        } else {
-          this.fileHashCache = currentFileHashes;
-          this.saveFileHashCache();
-        }
-        this.finalizeFailedBatchWriteState(failedProcessing.state);
         database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
         database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
         database.setMetadata(symbolExtractorMetadataKey, SYMBOL_EXTRACTOR_VERSION);
@@ -11211,6 +11560,13 @@ var Indexer = class _Indexer {
         this.indexCompatibility = { compatible: true };
         database.commitWriteTransaction();
         writeTransactionActive = false;
+        this.finalizeFailedBatchWriteState(failedProcessing.state, resolvedRetryChunkIds);
+        if (scopedRoots) {
+          this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
+        } else {
+          this.fileHashCache = currentFileHashes;
+          this.saveFileHashCache();
+        }
         stats.durationMs = Date.now() - startTime;
         onProgress?.({
           phase: "complete",
@@ -11245,15 +11601,15 @@ var Indexer = class _Indexer {
       );
       store.save();
       this.saveInvertedIndex(invertedIndex);
+      database.commitWriteTransaction();
+      writeTransactionActive = false;
+      this.finalizeFailedBatchWriteState(failedProcessing.state, resolvedRetryChunkIds);
       if (scopedRoots) {
         this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
       } else {
         this.fileHashCache = currentFileHashes;
         this.saveFileHashCache();
       }
-      this.finalizeFailedBatchWriteState(failedProcessing.state);
-      database.commitWriteTransaction();
-      writeTransactionActive = false;
       if (this.config.indexing.autoGc && stats.removedChunks > 0) {
         const gcReset = await this.maybeRunOrphanGc();
         if (gcReset) {
@@ -11277,6 +11633,9 @@ var Indexer = class _Indexer {
       if (forceScopedReembed && failedForcedChunkIds.size === 0) {
         database.deleteMetadata(this.getProjectForceReembedMetadataKey());
       }
+      if (forceScopedReembed) {
+        database.setMetadata(this.getProjectMigrationFinalizedMetadataKey(), "true");
+      }
       database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
       database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
       database.setMetadata(symbolExtractorMetadataKey, SYMBOL_EXTRACTOR_VERSION);
@@ -11387,26 +11746,41 @@ var Indexer = class _Indexer {
       shouldPrefilterByBranch: branchChunkIds !== null && (this.config.scope === "global" || hasInitializedBranchCatalog)
     };
   }
-  searchCandidatesWithBranchPrefilter(initialLimit, totalCount, branchChunkIds, shouldPrefilterByBranch, search, getChunkId) {
+  searchCandidatesWithAllowedIds(initialLimit, totalCount, allowedChunkIds, shouldPrefilter, search, getChunkId) {
     const normalizedLimit = Math.max(0, Math.floor(initialLimit));
     if (normalizedLimit === 0) return [];
-    if (!shouldPrefilterByBranch || !branchChunkIds) {
+    if (!shouldPrefilter || !allowedChunkIds) {
       return search(normalizedLimit);
     }
-    const targetCount = Math.min(normalizedLimit, branchChunkIds.size);
+    const targetCount = Math.min(normalizedLimit, allowedChunkIds.size);
     if (targetCount === 0 || totalCount === 0) return [];
     let requestedLimit = Math.min(normalizedLimit, totalCount);
     while (true) {
       const results = search(requestedLimit);
-      const branchResults = results.filter((candidate) => branchChunkIds.has(getChunkId(candidate)));
-      if (branchResults.length >= targetCount || results.length < requestedLimit || requestedLimit >= totalCount) {
-        return branchResults;
+      const allowedResults = results.filter((candidate) => allowedChunkIds.has(getChunkId(candidate)));
+      if (allowedResults.length >= targetCount || results.length < requestedLimit || requestedLimit >= totalCount) {
+        return allowedResults;
       }
       const nextLimit = Math.min(totalCount, Math.max(requestedLimit + 1, requestedLimit * 2));
-      if (nextLimit === requestedLimit) return branchResults;
+      if (nextLimit === requestedLimit) return allowedResults;
       requestedLimit = nextLimit;
     }
   }
+  getTemporalChunkIds(database, options) {
+    if (!options?.blameSince && !options?.blameUntil) return null;
+    const since = options.blameSince ? parseBlameTimestamp(options.blameSince, false) : void 0;
+    const until = options.blameUntil ? parseBlameTimestamp(options.blameUntil, true) : void 0;
+    if (since === null || until === null) {
+      return /* @__PURE__ */ new Set();
+    }
+    return new Set(database.getChunkIdsByBlameDate(since, until));
+  }
+  intersectChunkIdSets(first, second) {
+    if (first === null) return second;
+    if (second === null) return first;
+    const [smaller, larger] = first.size <= second.size ? [first, second] : [second, first];
+    return new Set(Array.from(smaller).filter((chunkId) => larger.has(chunkId)));
+  }
   buildCandidateSnapshot(candidate) {
     return {
       id: candidate.id,
@@ -11421,13 +11795,16 @@ var Indexer = class _Indexer {
   buildCandidateSnapshotList(candidates) {
     return candidates.map((candidate) => this.buildCandidateSnapshot(candidate));
   }
-  searchSemanticCandidates(store, embedding, initialLimit, branchChunkIds, shouldPrefilterByBranch) {
-    return this.searchCandidatesWithBranchPrefilter(
-      initialLimit,
-      store.count(),
+  searchSemanticCandidates(store, embedding, initialLimit, branchChunkIds, shouldPrefilterByBranch, temporalChunkIds) {
+    const availableCount = temporalChunkIds?.size ?? store.count();
+    if (availableCount === 0) return [];
+    const allowedIds = temporalChunkIds === null ? void 0 : Array.from(temporalChunkIds);
+    return this.searchCandidatesWithAllowedIds(
+      Math.min(initialLimit, availableCount),
+      availableCount,
       branchChunkIds,
       shouldPrefilterByBranch,
-      (requestedLimit) => store.search(embedding, requestedLimit),
+      (requestedLimit) => store.search(embedding, requestedLimit, allowedIds),
       (candidate) => candidate.id
     );
   }
@@ -11452,7 +11829,9 @@ var Indexer = class _Indexer {
     const rerankTopN = this.config.search.rerankTopN;
     const filterByBranch = options?.filterByBranch ?? true;
     const sourceIntent = options?.definitionIntent === true || classifyQueryIntentRaw(query) === "source";
+    const prioritizeSourcePaths = sourceIntent || options?.prioritizeSourcePaths === true;
     const identifierHints = extractIdentifierHints(query);
+    const candidateLimit = maxResults * (prioritizeSourcePaths ? 12 : 4);
     this.logger.search("debug", "Starting search", {
       query,
       maxResults,
@@ -11483,25 +11862,28 @@ var Indexer = class _Indexer {
       branchChunkIds = new Set(branchCatalogKeys.flatMap((branchKey) => database.getBranchChunkIds(branchKey)));
       branchSymbolIds = new Set(branchCatalogKeys.flatMap((branchKey) => database.getBranchSymbolIds(branchKey)));
     }
+    const temporalChunkIds = this.getTemporalChunkIds(database, options);
     const { hasInitializedBranchCatalog, shouldPrefilterByBranch } = this.getBranchPrefilterState(database, branchChunkIds);
     const prefilterMs = import_perf_hooks.performance.now() - prefilterStartTime;
     const vectorStartTime = import_perf_hooks.performance.now();
     const semanticCandidates = embedding ? this.searchSemanticCandidates(
       store,
       embedding,
-      maxResults * 4,
+      candidateLimit,
       branchChunkIds,
-      shouldPrefilterByBranch
+      shouldPrefilterByBranch,
+      temporalChunkIds
     ) : [];
     const vectorMs = import_perf_hooks.performance.now() - vectorStartTime;
     const keywordStartTime = import_perf_hooks.performance.now();
     const keywordCandidates = await this.keywordSearch(
       query,
-      maxResults * 4,
+      candidateLimit,
       store,
       invertedIndex,
       branchChunkIds,
-      shouldPrefilterByBranch
+      shouldPrefilterByBranch,
+      temporalChunkIds
     );
     const keywordMs = import_perf_hooks.performance.now() - keywordStartTime;
     const scopedSemanticCandidates = semanticCandidates.filter(
@@ -11523,7 +11905,7 @@ var Indexer = class _Indexer {
       rerankTopN,
       limit: maxResults,
       hybridWeight: rankingHybridWeight,
-      prioritizeSourcePaths: sourceIntent
+      prioritizeSourcePaths
     });
     const rerankedCombined = await this.rerankCandidatesWithApi(query, combined, {
       definitionIntent: options?.definitionIntent === true,
@@ -11559,10 +11941,11 @@ var Indexer = class _Indexer {
       branchSymbolIds,
       maxResults,
       union,
-      sourceIntent
+      sourceIntent,
+      options?.definitionIntent === true && ((options.directory?.trim().length ?? 0) > 0 || (options.fileType?.trim().length ?? 0) > 0)
     );
     const prePrimaryLane = mergeTieredResults(deterministicIdentifierLane, identifierLane, maxResults * 4);
-    const primaryLane = mergeTieredResults(prePrimaryLane, symbolLane, maxResults * 4);
+    const primaryLane = options?.definitionIntent === true ? mergeTieredResults(symbolLane, prePrimaryLane, maxResults * 4) : mergeTieredResults(prePrimaryLane, symbolLane, maxResults * 4);
     const tiered = mergeTieredResults(primaryLane, rescued, maxResults * 4);
     const hasCodeHints = extractCodeTermHints(query).length > 0 || identifierHints.length > 0;
     const baseFiltered = tiered.filter(
@@ -11657,14 +12040,18 @@ var Indexer = class _Indexer {
       })
     );
   }
-  async keywordSearch(query, limit, store, invertedIndex, branchChunkIds = null, shouldPrefilterByBranch = false) {
+  async keywordSearch(query, limit, store, invertedIndex, branchChunkIds = null, shouldPrefilterByBranch = false, temporalChunkIds = null) {
     const normalizedLimit = Math.max(0, Math.floor(limit));
     if (normalizedLimit === 0) return [];
-    const scoreEntries = this.searchCandidatesWithBranchPrefilter(
+    const allowedChunkIds = this.intersectChunkIdSets(
+      shouldPrefilterByBranch ? branchChunkIds : null,
+      temporalChunkIds
+    );
+    const scoreEntries = this.searchCandidatesWithAllowedIds(
       normalizedLimit,
       invertedIndex.getDocumentCount(),
-      branchChunkIds,
-      shouldPrefilterByBranch,
+      allowedChunkIds,
+      allowedChunkIds !== null,
       (requestedLimit) => Array.from(invertedIndex.search(query, requestedLimit)),
       ([chunkId]) => chunkId
     );
@@ -11749,7 +12136,17 @@ var Indexer = class _Indexer {
     );
     const currentFileHashes = /* @__PURE__ */ new Map();
     for (const file of files) {
-      currentFileHashes.set(this.toStoredFilePath(file.path), hashFile(file.path));
+      let hash;
+      try {
+        hash = hashFile(file.path);
+      } catch (error) {
+        this.logger.warn("Skipped unreadable file during freshness check", {
+          path: file.path,
+          error: getErrorMessage3(error)
+        });
+        return { readable: false, current: false, reason: "unreadable" };
+      }
+      currentFileHashes.set(this.toStoredFilePath(file.path), hash);
     }
     const scopedRoots = this.config.scope === "global" ? this.getScopedRoots() : null;
     const cachedFileHashes = scopedRoots ? new Map(Array.from(this.fileHashCache).filter(([filePath]) => this.isFileInCurrentScope(filePath, scopedRoots))) : this.fileHashCache;
@@ -11775,69 +12172,87 @@ var Indexer = class _Indexer {
   async forceIndex(onProgress) {
     return this.withIndexMutationLease("force-index", async (recoveredOwners) => {
       await this.ensureInitializedUnlocked(recoveredOwners);
-      await this.clearIndexUnlocked();
+      const recovery = this.beginClearRecoveryState();
+      await this.clearIndexUnlocked(recovery.compatibilityDecision);
+      this.finishClearRecoveryState();
       return this.indexUnlocked(onProgress, [], true);
     });
   }
   async clearIndex() {
     await this.withIndexMutationLease("clear", async (recoveredOwners) => {
       await this.ensureInitializedUnlocked(recoveredOwners);
-      await this.clearIndexUnlocked();
+      const recovery = this.beginClearRecoveryState();
+      await this.clearIndexUnlocked(recovery.compatibilityDecision);
     });
   }
-  async clearIndexUnlocked() {
+  clearGlobalIndexDataUnlocked(projectRoot = this.projectRoot) {
     const { store, invertedIndex, database } = this.requireLoadedIndexState();
-    if (this.config.scope === "global") {
-      store.load();
-      invertedIndex.load();
-      this.loadFileHashCache();
-      const roots = this.getScopedRoots();
-      const compatibility = this.checkCompatibility();
-      const allMetadata = store.getAllMetadata();
-      const hasForeignData = allMetadata.some(({ metadata }) => !this.isFileInCurrentScope(metadata.filePath, roots)) || this.hasForeignScopedBranchData() || this.hasForeignScopedFileHashData(roots) || this.hasForeignScopedFailedBatches(roots);
-      if (!compatibility.compatible && hasForeignData) {
-        if (compatibility.code === "EMBEDDING_STRATEGY_MISMATCH" /* EMBEDDING_STRATEGY_MISMATCH */) {
-          this.clearSharedIndexProjectData(store, invertedIndex, database, roots);
-          this.clearScopedFileHashCache(roots);
-          this.clearScopedFailedBatches(roots);
-          database.setMetadata(this.getProjectForceReembedMetadataKey(), "true");
-          database.deleteMetadata(this.getProjectEmbeddingStrategyMetadataKey());
+    const clearedBranchKeys = database.getAllBranches();
+    store.clear();
+    store.save();
+    invertedIndex.clear();
+    this.saveInvertedIndex(invertedIndex);
+    this.fileHashCache.clear();
+    this.saveFileHashCache();
+    database.clearAllIndexedData();
+    this.deleteBranchCommitMetadata(database, clearedBranchKeys);
+    this.clearFailedBatchState();
+    database.deleteMetadata("index.version");
+    database.deleteMetadata("index.pathStorageVersion");
+    database.deleteMetadata("index.embeddingProvider");
+    database.deleteMetadata("index.embeddingModel");
+    database.deleteMetadata("index.embeddingDimensions");
+    database.deleteMetadata("index.embeddingStrategyVersion");
+    const projectIdentityHash = this.getProjectIdentityHash(projectRoot);
+    database.deleteMetadata(this.getProjectEmbeddingStrategyMetadataKey(projectIdentityHash));
+    database.deleteMetadata(this.getProjectForceReembedMetadataKey(projectIdentityHash));
+    database.deleteMetadata(this.getLegacyMigrationMetadataKey(projectIdentityHash));
+    database.deleteMetadata("index.createdAt");
+    database.deleteMetadata("index.updatedAt");
+    this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
+  }
+  clearGlobalIndexUnlocked(projectRoot = this.projectRoot, roots = this.getScopedRoots(), recoveryDecision) {
+    const { store, invertedIndex, database } = this.requireLoadedIndexState();
+    store.load();
+    invertedIndex.load();
+    this.loadFileHashCache();
+    const compatibility = this.checkCompatibility();
+    const compatibilityDecision = recoveryDecision ?? (compatibility.compatible ? "compatible" : compatibility.code === "EMBEDDING_STRATEGY_MISMATCH" /* EMBEDDING_STRATEGY_MISMATCH */ ? "embedding-strategy-mismatch" : "incompatible");
+    const allMetadata = store.getAllMetadata();
+    const hasForeignData = allMetadata.some(({ metadata }) => !this.isFileInCurrentScope(metadata.filePath, roots)) || this.hasForeignScopedBranchData(projectRoot, roots) || this.hasForeignScopedFileHashData(roots) || this.hasForeignScopedFailedBatches(roots);
+    if (compatibilityDecision !== "compatible" && hasForeignData) {
+      if (compatibilityDecision === "embedding-strategy-mismatch") {
+        this.clearSharedIndexProjectData(store, invertedIndex, database, roots, projectRoot);
+        this.clearScopedFileHashCache(roots);
+        this.clearScopedFailedBatches(roots);
+        const projectIdentityHash = this.getProjectIdentityHash(projectRoot);
+        database.setMetadata(this.getProjectForceReembedMetadataKey(projectIdentityHash), "true");
+        database.deleteMetadata(this.getProjectEmbeddingStrategyMetadataKey(projectIdentityHash));
+        database.deleteMetadata(this.getProjectMigrationFinalizedMetadataKey(projectIdentityHash));
+        if (projectRoot === this.projectRoot) {
           this.indexCompatibility = { compatible: true };
-          return;
         }
-        throw new Error(
-          `Global index compatibility reset is unsafe because the shared index contains files from other projects. The current global index cannot be force-rebuilt for ${this.projectRoot} without deleting other repositories' indexed data. Use scope="project" for isolated rebuilds, or manually delete the shared global index if you intend to rebuild all projects.`
-        );
-      }
-      if (!hasForeignData) {
-        const clearedBranchKeys2 = database.getAllBranches();
-        store.clear();
-        store.save();
-        invertedIndex.clear();
-        this.saveInvertedIndex(invertedIndex);
-        this.fileHashCache.clear();
-        this.saveFileHashCache();
-        database.clearAllIndexedData();
-        this.deleteBranchCommitMetadata(database, clearedBranchKeys2);
-        this.clearFailedBatchState();
-        database.deleteMetadata("index.version");
-        database.deleteMetadata("index.pathStorageVersion");
-        database.deleteMetadata("index.embeddingProvider");
-        database.deleteMetadata("index.embeddingModel");
-        database.deleteMetadata("index.embeddingDimensions");
-        database.deleteMetadata("index.embeddingStrategyVersion");
-        database.deleteMetadata(this.getProjectEmbeddingStrategyMetadataKey());
-        database.deleteMetadata(this.getProjectForceReembedMetadataKey());
-        database.deleteMetadata(this.getLegacyMigrationMetadataKey());
-        database.deleteMetadata("index.createdAt");
-        database.deleteMetadata("index.updatedAt");
-        this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
         return;
       }
-      this.clearSharedIndexProjectData(store, invertedIndex, database, roots);
-      this.clearScopedFileHashCache(roots);
-      this.clearScopedFailedBatches(roots);
+      throw new Error(
+        `Global index compatibility reset is unsafe because the shared index contains files from other projects. The current global index cannot be force-rebuilt for ${projectRoot} without deleting other repositories' indexed data. Use scope="project" for isolated rebuilds, or manually delete the shared global index if you intend to rebuild all projects.`
+      );
+    }
+    if (!hasForeignData) {
+      this.clearGlobalIndexDataUnlocked(projectRoot);
+      return;
+    }
+    this.clearSharedIndexProjectData(store, invertedIndex, database, roots, projectRoot);
+    this.clearScopedFileHashCache(roots);
+    this.clearScopedFailedBatches(roots);
+    if (projectRoot === this.projectRoot) {
       this.indexCompatibility = compatibility;
+    }
+  }
+  async clearIndexUnlocked(recoveryDecision) {
+    const { store, invertedIndex, database } = this.requireLoadedIndexState();
+    if (this.config.scope === "global") {
+      this.clearGlobalIndexUnlocked(this.projectRoot, this.getScopedRoots(), recoveryDecision);
       return;
     }
     if (!this.isProjectOwnedIndexPath()) {
@@ -12003,6 +12418,7 @@ var Indexer = class _Indexer {
       )) {
         const chunks = retryBatch.map(({ chunk }) => chunk);
         const attemptCounts = new Map(retryBatch.map(({ chunk, attemptCount }) => [chunk.id, attemptCount]));
+        this.restoreMissingChunkRows(database, chunks);
         const batchResult = await this.processPendingChunkBatch(chunks, {
           store,
           provider,
@@ -12017,6 +12433,7 @@ var Indexer = class _Indexer {
           forceReembed: false,
           reuseCachedEmbeddings: false,
           incrementRepeatedFailures: false,
+          forceSingleItemBatches: true,
           onSucceeded: (succeededChunks) => {
             database.addChunksToBranchBatch(
               this.getBranchCatalogKey(),
@@ -12038,9 +12455,12 @@ var Indexer = class _Indexer {
       this.saveInvertedIndex(invertedIndex);
     }
     if (roots && succeeded > 0 && remaining === 0 && this.hasProjectForceReembedPending()) {
-      database.deleteMetadata(this.getProjectForceReembedMetadataKey());
-      this.saveIndexMetadata(configuredProviderInfo);
-      this.indexCompatibility = { compatible: true };
+      const migrationFinalized = database.getMetadata(this.getProjectMigrationFinalizedMetadataKey()) === "true";
+      if (migrationFinalized) {
+        database.deleteMetadata(this.getProjectForceReembedMetadataKey());
+        this.saveIndexMetadata(configuredProviderInfo);
+        this.indexCompatibility = { compatible: true };
+      }
     }
     return { succeeded, failed, remaining };
   }
@@ -12062,7 +12482,8 @@ var Indexer = class _Indexer {
           latestById.set(chunkId, {
             attemptCount: batch.attemptCount,
             error: batch.error,
-            lastAttempt: batch.lastAttempt
+            lastAttempt: batch.lastAttempt,
+            chunks: [rawChunk]
           });
         }
       }
@@ -12129,6 +12550,7 @@ var Indexer = class _Indexer {
         this.getBranchCatalogKeys().flatMap((branchKey) => database.getBranchChunkIds(branchKey))
       );
     }
+    const temporalChunkIds = this.getTemporalChunkIds(database, options);
     const { hasInitializedBranchCatalog, shouldPrefilterByBranch } = this.getBranchPrefilterState(database, branchChunkIds);
     const prefilterMs = import_perf_hooks.performance.now() - prefilterStartTime;
     const vectorStartTime = import_perf_hooks.performance.now();
@@ -12137,7 +12559,8 @@ var Indexer = class _Indexer {
       embedding,
       limit * 2,
       branchChunkIds,
-      shouldPrefilterByBranch
+      shouldPrefilterByBranch,
+      temporalChunkIds
     );
     const vectorMs = import_perf_hooks.performance.now() - vectorStartTime;
     if (this.config.scope !== "global" && branchChunkIds && !hasInitializedBranchCatalog) {
@@ -12255,9 +12678,9 @@ var Indexer = class _Indexer {
     this.requireReadableComponents(readIssues, "database");
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path31 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path31.length > 0 && (shortest.length === 0 || path31.length < shortest.length)) {
-        shortest = path31;
+      const path33 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path33.length > 0 && (shortest.length === 0 || path33.length < shortest.length)) {
+        shortest = path33;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -12305,13 +12728,13 @@ var Indexer = class _Indexer {
         }
       }
       if (!found) continue;
-      const path31 = [];
+      const path33 = [];
       let currentSymbolId = toSymbolId;
       while (true) {
         const symbol = symbolsById.get(currentSymbolId);
         if (!symbol) break;
         const parent = parentBySymbolId.get(currentSymbolId);
-        path31.push({
+        path33.push({
           symbolId: symbol.id,
           symbolName: symbol.name,
           filePath: symbol.filePath,
@@ -12321,9 +12744,9 @@ var Indexer = class _Indexer {
         if (!parent) break;
         currentSymbolId = parent.parentId;
       }
-      path31.reverse();
-      if (path31.length > 0 && (shortest.length === 0 || path31.length < shortest.length)) {
-        shortest = path31;
+      path33.reverse();
+      if (path33.length > 0 && (shortest.length === 0 || path33.length < shortest.length)) {
+        shortest = path33;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -12659,7 +13082,6 @@ var Indexer = class _Indexer {
     this.store = null;
     this.invertedIndex = null;
     this.provider = null;
-    this.reranker = null;
     this.configuredProviderInfo = null;
     this.indexCompatibility = null;
     this.initializationMode = "none";
@@ -12720,6 +13142,36 @@ function resolveConfigPathValue(value, baseDir) {
   const absolutePath = path16.isAbsolute(trimmed) ? trimmed : path16.resolve(baseDir, trimmed);
   return path16.normalize(absolutePath);
 }
+function serializeConfigPathValue(value, baseDir) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  if (!path16.isAbsolute(trimmed)) {
+    return normalizePathSeparators(path16.normalize(trimmed));
+  }
+  const relativePath = path16.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path16.isAbsolute(relativePath)) {
+    return normalizePathSeparators(path16.normalize(relativePath || "."));
+  }
+  return path16.normalize(trimmed);
+}
+function resolveKnowledgeBasePath(value, projectRoot) {
+  return path16.isAbsolute(value) ? value : path16.resolve(projectRoot, value);
+}
+function normalizeKnowledgeBasePath(value, projectRoot) {
+  return path16.normalize(resolveKnowledgeBasePath(value, projectRoot));
+}
+function hasMatchingKnowledgeBasePath(knowledgeBases, inputPath, projectRoot) {
+  const normalizedInput = path16.normalize(inputPath);
+  return knowledgeBases.some((kb) => normalizeKnowledgeBasePath(kb, projectRoot) === normalizedInput);
+}
+function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot) {
+  const normalizedInput = path16.normalize(inputPath);
+  return knowledgeBases.findIndex(
+    (kb) => path16.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath(kb, projectRoot) === normalizedInput
+  );
+}
 
 // src/tools/format-communities.ts
 function compareText(left, right) {
@@ -12973,8 +13425,8 @@ function formatExactSearchHandoff(results) {
 }
 function formatContextEvidence(result, index) {
   const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
-  const path31 = compactEvidenceValue(result.filePath, 120);
-  return `[${index}] ${result.chunkType}${symbol} in ${path31}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+  const path33 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path33}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
 }
 function formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, budgetOmittedCount, includeExactSearchHandoff) {
   const lines = selected.map((result, index) => formatContextEvidence(result, index + 1));
@@ -13628,7 +14080,7 @@ function getErrorMessage4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function runCommand(file, args, options) {
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve20, reject) => {
     childProcess.execFile(
       file,
       args,
@@ -13638,7 +14090,7 @@ function runCommand(file, args, options) {
           reject(error);
           return;
         }
-        resolve18(stdout);
+        resolve20(stdout);
       }
     );
   });
@@ -13783,10 +14235,10 @@ function safeFailureMessage(error) {
 }
 function cancellableDelay(delayMs, signal) {
   if (signal.aborted) return Promise.reject(new AutoIndexCancelledError());
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve20, reject) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve18();
+      resolve20();
     }, delayMs);
     timer.unref?.();
     const onAbort = () => {
@@ -13798,15 +14250,15 @@ function cancellableDelay(delayMs, signal) {
 }
 function withTimeout(promise, timeoutMs) {
   if (timeoutMs <= 0) return Promise.resolve(void 0);
-  return new Promise((resolve18) => {
-    const timer = setTimeout(() => resolve18(void 0), timeoutMs);
+  return new Promise((resolve20) => {
+    const timer = setTimeout(() => resolve20(void 0), timeoutMs);
     timer.unref?.();
     void promise.then((value) => {
       clearTimeout(timer);
-      resolve18(value);
+      resolve20(value);
     }, () => {
       clearTimeout(timer);
-      resolve18(void 0);
+      resolve20(void 0);
     });
   });
 }
@@ -14188,17 +14640,17 @@ var AutoIndexCoordinator = class {
     }
   }
   waitForBatteryRetry(delayMs) {
-    return new Promise((resolve18) => {
+    return new Promise((resolve20) => {
       const timer = setTimeout(() => {
         if (this.batteryRetryTimer === timer) {
           this.batteryRetryTimer = null;
           this.resolveBatteryRetry = null;
         }
-        resolve18();
+        resolve20();
       }, delayMs);
       timer.unref?.();
       this.batteryRetryTimer = timer;
-      this.resolveBatteryRetry = resolve18;
+      this.resolveBatteryRetry = resolve20;
     });
   }
   cancelBatteryRetry() {
@@ -14206,9 +14658,9 @@ var AutoIndexCoordinator = class {
       clearTimeout(this.batteryRetryTimer);
       this.batteryRetryTimer = null;
     }
-    const resolve18 = this.resolveBatteryRetry;
+    const resolve20 = this.resolveBatteryRetry;
     this.resolveBatteryRetry = null;
-    resolve18?.();
+    resolve20?.();
   }
   finishBatteryCheck(batteryCheck) {
     if (this.batteryCheck !== batteryCheck) return;
@@ -14426,7 +14878,7 @@ function applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key
 function mergeUniqueStringArray(values) {
   return [...new Set(values.map((value) => String(value).trim()))];
 }
-function normalizeKnowledgeBasePath(value) {
+function normalizeKnowledgeBasePath2(value) {
   let normalized = path19.normalize(String(value).trim());
   const root = path19.parse(normalized).root;
   while (normalized.length > root.length && /[\\/]$/.test(normalized)) {
@@ -14435,7 +14887,7 @@ function normalizeKnowledgeBasePath(value) {
   return normalized;
 }
 function mergeKnowledgeBasePaths(values) {
-  return [...new Set(values.map((value) => normalizeKnowledgeBasePath(value)).filter((value) => value.length > 0))];
+  return [...new Set(values.map((value) => normalizeKnowledgeBasePath2(value)).filter((value) => value.length > 0))];
 }
 function validateConfigLayerShape(rawConfig, filePath) {
   if (!isRecord(rawConfig)) {
@@ -14565,9 +15017,30 @@ function toConfigRecord(rawConfig) {
   }
   return { ...rawConfig };
 }
+function getConfigPath(projectRoot, host) {
+  return resolveWritableProjectConfigPath(projectRoot, host);
+}
 function loadRuntimeConfig(projectRoot, host) {
   return normalizeKnowledgeBasePaths(toConfigRecord(loadMergedConfig(projectRoot, host)), projectRoot);
 }
+function loadEditableConfig(projectRoot, host) {
+  return normalizeKnowledgeBasePaths(toConfigRecord(loadProjectConfigLayer(projectRoot, host)), projectRoot);
+}
+function saveConfig(projectRoot, config, host) {
+  const configPath = getConfigPath(projectRoot, host);
+  const configDir = path20.dirname(configPath);
+  const configBaseDir = path20.dirname(configDir);
+  if (!(0, import_fs13.existsSync)(configDir)) {
+    (0, import_fs13.mkdirSync)(configDir, { recursive: true });
+  }
+  const serializableConfig = { ...config };
+  if (Array.isArray(serializableConfig.knowledgeBases)) {
+    serializableConfig.knowledgeBases = serializableConfig.knowledgeBases.map(
+      (kb) => serializeConfigPathValue(kb, configBaseDir)
+    );
+  }
+  (0, import_fs13.writeFileSync)(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
+}
 
 // src/tools/operation-runtime.ts
 var indexerCache = /* @__PURE__ */ new Map();
@@ -14786,9 +15259,11 @@ async function searchCodebase(projectRoot, host, query, options = {}) {
     contextLines: options.contextLines,
     metadataOnly: options.metadataOnly,
     definitionIntent: options.definitionIntent,
+    prioritizeSourcePaths: options.prioritizeSourcePaths,
     blameAuthor: options.blameAuthor,
     blameSha: options.blameSha,
     blameSince: options.blameSince,
+    blameUntil: options.blameUntil,
     trace: options.trace
   });
 }
@@ -14834,7 +15309,9 @@ async function findSimilarCode(projectRoot, host, code, options = {}) {
     fileType: options.fileType,
     directory: options.directory,
     chunkType: options.chunkType,
-    excludeFile: options.excludeFile
+    excludeFile: options.excludeFile,
+    blameSince: options.blameSince,
+    blameUntil: options.blameUntil
   });
 }
 async function implementationLookup(projectRoot, host, query, options = {}) {
@@ -14883,12 +15360,12 @@ async function getCallGraphPath(projectRoot, host, from, to, maxDepth, fromFileP
   if (fromResolution.status !== "resolved" || toResolution.status !== "resolved") {
     return { from: fromResolution, to: toResolution, path: [] };
   }
-  const path31 = await indexer.findCallPathBySymbolIds(
+  const path33 = await indexer.findCallPathBySymbolIds(
     fromResolution.symbolId,
     toResolution.symbolId,
     maxDepth
   );
-  return { from: fromResolution, to: toResolution, path: path31 };
+  return { from: fromResolution, to: toResolution, path: path33 };
 }
 async function runIndexCodebase(projectRoot, host, args, onProgress) {
   const root = getProjectRoot(projectRoot, host);
@@ -15080,6 +15557,141 @@ async function getIndexLogs(projectRoot, host, args) {
   }).join("\n");
   return { kind: "entries", text };
 }
+function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
+  const root = getProjectRoot(projectRoot, host);
+  const inputPath = knowledgeBasePath.trim();
+  const normalizedPath3 = path21.resolve(
+    path21.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
+  );
+  if (!(0, import_fs14.existsSync)(normalizedPath3)) {
+    return `Error: Directory does not exist: ${normalizedPath3}`;
+  }
+  let realPath;
+  try {
+    realPath = (0, import_fs14.realpathSync)(normalizedPath3);
+  } catch {
+    return `Error: Cannot resolve path: ${normalizedPath3}`;
+  }
+  const blockedPrefixes = [
+    "/etc",
+    "/proc",
+    "/sys",
+    "/dev",
+    "/boot",
+    "/root",
+    "/var/run",
+    "/var/log"
+  ];
+  const homeDir = process.platform === "win32" ? process.env.USERPROFILE ?? "" : process.env.HOME ?? "";
+  const sensitiveDotDirs = [
+    ".ssh",
+    ".gnupg",
+    ".aws",
+    ".config/gcloud",
+    ".docker",
+    ".kube"
+  ];
+  for (const prefix of blockedPrefixes) {
+    if (realPath === prefix || realPath.startsWith(`${prefix}/`)) {
+      return `Error: Adding sensitive directory as knowledge base is not allowed: ${normalizedPath3}`;
+    }
+  }
+  for (const dotDir of sensitiveDotDirs) {
+    const sensitiveDir = path21.join(homeDir, dotDir);
+    if (sensitiveDir && (realPath === sensitiveDir || realPath.startsWith(`${sensitiveDir}/`))) {
+      return `Error: Adding sensitive directory as knowledge base is not allowed: ${normalizedPath3}`;
+    }
+  }
+  try {
+    const stat5 = (0, import_fs14.statSync)(normalizedPath3);
+    if (!stat5.isDirectory()) {
+      return `Error: Path is not a directory: ${normalizedPath3}`;
+    }
+  } catch (error) {
+    return `Error: Cannot access directory: ${normalizedPath3} - ${error instanceof Error ? error.message : String(error)}`;
+  }
+  const config = loadEditableConfig(root, host);
+  const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
+  const alreadyExists = hasMatchingKnowledgeBasePath(knowledgeBases, normalizedPath3, root);
+  if (alreadyExists) {
+    return `Knowledge base already configured: ${normalizedPath3}`;
+  }
+  knowledgeBases.push(normalizedPath3);
+  config.knowledgeBases = knowledgeBases;
+  saveConfig(root, config, host);
+  refreshIndexerForDirectory(root, host);
+  let result = `${normalizedPath3}
+`;
+  result += `Total knowledge bases: ${knowledgeBases.length}
+`;
+  result += `Config path: ${getConfigPath(root, host)}
+`;
+  result += `
+Run /index to rebuild the index with the new knowledge base.`;
+  return result;
+}
+function listKnowledgeBases(projectRoot, host) {
+  const root = getProjectRoot(projectRoot, host);
+  const config = loadRuntimeConfig(root, host);
+  const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
+  if (knowledgeBases.length === 0) {
+    return "No knowledge bases configured. Use add_knowledge_base to add folders.";
+  }
+  let result = `Knowledge Bases (${knowledgeBases.length}):
+
+`;
+  for (let i = 0; i < knowledgeBases.length; i++) {
+    const kb = knowledgeBases[i];
+    const resolvedPath = resolveKnowledgeBasePath(kb, root);
+    const exists = (0, import_fs14.existsSync)(resolvedPath);
+    result += `[${i + 1}] ${kb}
+`;
+    result += `    Resolved: ${resolvedPath}
+`;
+    result += `    Status: ${exists ? "Exists" : "NOT FOUND"}
+`;
+    if (exists) {
+      try {
+        const stat5 = (0, import_fs14.statSync)(resolvedPath);
+        result += `    Type: ${stat5.isDirectory() ? "Directory" : "File"}
+`;
+      } catch {
+      }
+    }
+    result += "\n";
+  }
+  const hasHostConfig = (0, import_fs14.existsSync)(path21.join(root, getHostProjectConfigRelativePath(host)));
+  if (hasHostConfig) {
+    result += `
+Config sources: 1 file(s).`;
+  }
+  result += `
+Config file: ${getConfigPath(root, host)}`;
+  return result;
+}
+function removeKnowledgeBase(projectRoot, host, knowledgeBasePath) {
+  const root = getProjectRoot(projectRoot, host);
+  const config = loadEditableConfig(root, host);
+  const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
+  const index = findKnowledgeBasePathIndex(knowledgeBases, knowledgeBasePath, root);
+  if (index === -1) {
+    return `Knowledge base not found: ${knowledgeBasePath}`;
+  }
+  const removed = knowledgeBases.splice(index, 1)[0];
+  config.knowledgeBases = knowledgeBases;
+  saveConfig(root, config, host);
+  refreshIndexerForDirectory(root, host);
+  let result = `Removed: ${removed}
+
+`;
+  result += `Remaining knowledge bases: ${knowledgeBases.length}
+`;
+  result += `Config saved to: ${getConfigPath(root, host)}
+`;
+  result += `
+Run /index to rebuild the index without the removed knowledge base.`;
+  return result;
+}
 
 // src/tools/context-search.ts
 var MIN_CONTEXT_RESULT_LIMIT = 1;
@@ -15308,13 +15920,19 @@ async function resolveSearchContext(input, operations) {
       (trace) => operations.lookup(symbol, MAX_CONTEXT_RESULT_LIMIT, scope, input.diagnostic ? trace : void 0)
     );
   };
-  const tryConceptualSearch = async (searchQuery, scope, relaxedFieldsForAttempt) => {
+  const tryConceptualSearch = async (searchQuery, scope, relaxedFieldsForAttempt, prioritizeSourcePaths) => {
     return recordAttempt(
       "conceptual",
       searchQuery,
       scope,
       relaxedFieldsForAttempt,
-      (trace) => operations.search(searchQuery, MAX_CONTEXT_RESULT_LIMIT, scope, input.diagnostic ? trace : void 0)
+      (trace) => operations.search(
+        searchQuery,
+        MAX_CONTEXT_RESULT_LIMIT,
+        scope,
+        input.diagnostic ? trace : void 0,
+        { prioritizeSourcePaths }
+      )
     );
   };
   const findSuccessfulAttemptState = (route) => {
@@ -15442,10 +16060,12 @@ Explicit symbol lookup only; conceptual search was not attempted.`
     }
   }
   for (const attempt of conceptualAttemptPlan) {
+    const attemptIntent = analyzeQueryIntent(attempt.queryText);
+    const prioritizeSourcePaths = attemptIntent.primary !== "docs" && attemptIntent.primary !== "test";
     if (inferredSymbol && attempt.queryText === inferredSymbol && attempt.queryText !== query) {
       decisions.fallbackFromOriginalConceptualToInferred = true;
     }
-    const results = await tryConceptualSearch(attempt.queryText, attempt.scope, attempt.relaxed);
+    const results = await tryConceptualSearch(attempt.queryText, attempt.scope, attempt.relaxed, prioritizeSourcePaths);
     if (results.length > 0) {
       const heading = buildPackHeading("conceptual", decisions);
       const intent = analyzeQueryIntent(attempt.queryText);
@@ -15513,7 +16133,7 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
   const directory = input.directory ?? void 0;
   const tokenBudget = input.tokenBudget ?? void 0;
   if (from && to) {
-    const path31 = await getCallGraphPath(
+    const path33 = await getCallGraphPath(
       projectRoot,
       host,
       from,
@@ -15522,25 +16142,25 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
       fromFilePath,
       toFilePath
     );
-    const pathText = formatCallGraphPathResult(path31);
-    if (path31.path.length > 0) {
+    const pathText = formatCallGraphPathResult(path33);
+    if (path33.path.length > 0) {
       const fitted2 = fitTextToContextBudget(
         pathText,
         tokenBudget
       );
       return {
         text: fitted2.text,
-        details: fittedDetails("path", fitted2, path31.path.length)
+        details: fittedDetails("path", fitted2, path33.path.length)
       };
     }
-    if (path31.from.status !== "resolved" || path31.to.status !== "resolved") {
+    if (path33.from.status !== "resolved" || path33.to.status !== "resolved") {
       const fitted2 = fitTextToContextBudget(pathText, tokenBudget);
       return {
         text: fitted2.text,
         details: fittedDetails("path", fitted2, 0)
       };
     }
-    const resolvedFrom = path31.from;
+    const resolvedFrom = path33.from;
     const { callers } = await getCallGraphData(projectRoot, host, {
       name: to,
       direction: "callers",
@@ -15582,12 +16202,13 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
       directory: scope.directory,
       trace
     }),
-    search: (queryText, retrievalLimit, scope, trace) => searchCodebase(projectRoot, host, queryText, {
+    search: (queryText, retrievalLimit, scope, trace, searchOptions) => searchCodebase(projectRoot, host, queryText, {
       limit: retrievalLimit,
       fileType: scope.fileType,
       directory: scope.directory,
       metadataOnly: true,
-      trace
+      trace,
+      prioritizeSourcePaths: searchOptions?.prioritizeSourcePaths
     })
   });
 }
@@ -16017,9 +16638,9 @@ function getRelevantEvidence(query) {
     });
   }
   if (query.expected.acceptableFiles) {
-    for (const path31 of query.expected.acceptableFiles) {
+    for (const path33 of query.expected.acceptableFiles) {
       legacyEvidence.push({
-        path: path31,
+        path: path33,
         ...query.expected.symbol !== void 0 ? { symbol: query.expected.symbol } : {},
         relevance: 1
       });
@@ -16516,68 +17137,68 @@ function isStringArray4(value) {
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
-function asPositiveNumber(value, path31) {
+function asPositiveNumber(value, path33) {
   if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
-    throw new Error(`${path31} must be a non-negative number`);
+    throw new Error(`${path33} must be a non-negative number`);
   }
   return value;
 }
-function parseQueryType(value, path31) {
+function parseQueryType(value, path33) {
   if (value === "definition" || value === "implementation-intent" || value === "similarity" || value === "keyword-heavy" || value === "conceptual") {
     return value;
   }
   throw new Error(
-    `${path31} must be one of: definition, implementation-intent, similarity, keyword-heavy, conceptual`
+    `${path33} must be one of: definition, implementation-intent, similarity, keyword-heavy, conceptual`
   );
 }
-function parseExpectedRoute(value, path31) {
+function parseExpectedRoute(value, path33) {
   if (value === void 0) return void 0;
   if (value === "search" || value === "definition") return value;
-  throw new Error(`${path31} must be one of: search, definition`);
+  throw new Error(`${path33} must be one of: search, definition`);
 }
-function parseExpectedOutcome(value, path31) {
+function parseExpectedOutcome(value, path33) {
   if (value === void 0) return void 0;
   if (value === "results" || value === "no-results") {
     return value;
   }
-  throw new Error(`${path31} must be one of: results, no-results`);
+  throw new Error(`${path33} must be one of: results, no-results`);
 }
-function parseRecoveryExpectation(value, path31) {
+function parseRecoveryExpectation(value, path33) {
   if (value === void 0) return void 0;
   if (value === "none" || value === "filter-relaxed") {
     return value;
   }
-  throw new Error(`${path31} must be one of: none, filter-relaxed`);
+  throw new Error(`${path33} must be one of: none, filter-relaxed`);
 }
-function parseQueryDifficulty(value, path31) {
+function parseQueryDifficulty(value, path33) {
   if (value === void 0) return void 0;
   if (value === "easy" || value === "medium" || value === "hard") {
     return value;
   }
-  throw new Error(`${path31} must be one of: easy, medium, hard`);
+  throw new Error(`${path33} must be one of: easy, medium, hard`);
 }
-function parseQueryTags(value, path31) {
+function parseQueryTags(value, path33) {
   if (value === void 0) return void 0;
   if (!isStringArray4(value) || value.some((tag) => tag.trim().length === 0)) {
-    throw new Error(`${path31} must be an array of non-empty strings`);
+    throw new Error(`${path33} must be an array of non-empty strings`);
   }
   if (value.length > 16) {
-    throw new Error(`${path31} must contain at most 16 tags`);
+    throw new Error(`${path33} must contain at most 16 tags`);
   }
   return value;
 }
-function parseQueryArgs(value, path31) {
+function parseQueryArgs(value, path33) {
   if (value === void 0) return void 0;
   if (!isRecord3(value)) {
-    throw new Error(`${path31} must be an object`);
-  }
-  const symbol = parseStringOrUndefined(value.symbol, `${path31}.symbol`);
-  const filePath = parseStringOrUndefined(value.filePath, `${path31}.filePath`);
-  const fileType = parseStringOrUndefined(value.fileType, `${path31}.fileType`);
-  const directory = parseStringOrUndefined(value.directory, `${path31}.directory`);
-  const callerLimit = parsePositiveIntegerOrUndefined(value.callerLimit, `${path31}.callerLimit`);
-  const calleeLimit = parsePositiveIntegerOrUndefined(value.calleeLimit, `${path31}.calleeLimit`);
-  const tokenBudget = parsePositiveIntegerOrUndefined(value.tokenBudget, `${path31}.tokenBudget`);
+    throw new Error(`${path33} must be an object`);
+  }
+  const symbol = parseStringOrUndefined(value.symbol, `${path33}.symbol`);
+  const filePath = parseStringOrUndefined(value.filePath, `${path33}.filePath`);
+  const fileType = parseStringOrUndefined(value.fileType, `${path33}.fileType`);
+  const directory = parseStringOrUndefined(value.directory, `${path33}.directory`);
+  const callerLimit = parsePositiveIntegerOrUndefined(value.callerLimit, `${path33}.callerLimit`);
+  const calleeLimit = parsePositiveIntegerOrUndefined(value.calleeLimit, `${path33}.calleeLimit`);
+  const tokenBudget = parsePositiveIntegerOrUndefined(value.tokenBudget, `${path33}.tokenBudget`);
   return {
     ...symbol !== void 0 ? { symbol } : {},
     ...filePath !== void 0 ? { filePath } : {},
@@ -16588,50 +17209,50 @@ function parseQueryArgs(value, path31) {
     ...tokenBudget !== void 0 ? { tokenBudget } : {}
   };
 }
-function parsePositiveIntegerOrUndefined(value, path31) {
+function parsePositiveIntegerOrUndefined(value, path33) {
   if (value === void 0 || value === null) return void 0;
   if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-    throw new Error(`${path31} must be a positive integer`);
+    throw new Error(`${path33} must be a positive integer`);
   }
   return value;
 }
 var SEMVER_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-function parseSemanticVersion(value, path31) {
+function parseSemanticVersion(value, path33) {
   if (!isNonEmptyString(value)) {
-    throw new Error(`${path31} must be a non-empty string`);
+    throw new Error(`${path33} must be a non-empty string`);
   }
   if (!SEMVER_VERSION_PATTERN.test(value)) {
-    throw new Error(`${path31} must be a valid semantic version (MAJOR.MINOR.PATCH)`);
+    throw new Error(`${path33} must be a valid semantic version (MAJOR.MINOR.PATCH)`);
   }
   return value;
 }
-function parseRetrievalMode(value, path31) {
+function parseRetrievalMode(value, path33) {
   if (value === void 0 || value === "search") return "search";
   if (value === "context" || value === "edit-context") return value;
-  throw new Error(`${path31} must be one of: search, context, edit-context`);
+  throw new Error(`${path33} must be one of: search, context, edit-context`);
 }
-function parseStringOrUndefined(value, path31) {
+function parseStringOrUndefined(value, path33) {
   if (value === void 0 || value === null) return void 0;
   if (!isNonEmptyString(value)) {
-    throw new Error(`${path31} must be a non-empty string`);
+    throw new Error(`${path33} must be a non-empty string`);
   }
   return value;
 }
-function parseGradedEvidence(value, path31) {
+function parseGradedEvidence(value, path33) {
   if (value === void 0) return [];
   if (!Array.isArray(value)) {
-    throw new Error(`${path31} must be an array`);
+    throw new Error(`${path33} must be an array`);
   }
   return value.map((entry, index) => {
     if (!isRecord3(entry)) {
-      throw new Error(`${path31}[${index}] must be an object`);
+      throw new Error(`${path33}[${index}] must be an object`);
     }
-    const evidencePath = parseStringOrUndefined(entry.path, `${path31}[${index}].path`);
+    const evidencePath = parseStringOrUndefined(entry.path, `${path33}[${index}].path`);
     if (evidencePath === void 0) {
-      throw new Error(`${path31}[${index}].path is required`);
+      throw new Error(`${path33}[${index}].path is required`);
     }
-    const symbol = parseStringOrUndefined(entry.symbol, `${path31}[${index}].symbol`);
-    const relevance = parseEvidenceRelevance(entry.relevance, `${path31}[${index}].relevance`);
+    const symbol = parseStringOrUndefined(entry.symbol, `${path33}[${index}].symbol`);
+    const relevance = parseEvidenceRelevance(entry.relevance, `${path33}[${index}].relevance`);
     return {
       path: evidencePath,
       ...symbol !== void 0 ? { symbol } : {},
@@ -16639,27 +17260,27 @@ function parseGradedEvidence(value, path31) {
     };
   });
 }
-function parseEvidenceRelevance(value, path31) {
+function parseEvidenceRelevance(value, path33) {
   if (value === void 0) {
-    throw new Error(`${path31} is required`);
+    throw new Error(`${path33} is required`);
   }
   if (value !== 1 && value !== 2 && value !== 3) {
-    throw new Error(`${path31} must be 1, 2, or 3`);
+    throw new Error(`${path33} must be 1, 2, or 3`);
   }
   return value;
 }
-function parseExpectedGraphNeighbor(value, path31) {
+function parseExpectedGraphNeighbor(value, path33) {
   if (value === void 0) return void 0;
   if (!isRecord3(value)) {
-    throw new Error(`${path31} must be an object`);
+    throw new Error(`${path33} must be an object`);
   }
   if (value.direction !== "caller" && value.direction !== "callee") {
-    throw new Error(`${path31}.direction must be one of: caller, callee`);
+    throw new Error(`${path33}.direction must be one of: caller, callee`);
   }
-  const filePath = parseStringOrUndefined(value.filePath, `${path31}.filePath`);
-  const symbol = parseStringOrUndefined(value.symbol, `${path31}.symbol`);
+  const filePath = parseStringOrUndefined(value.filePath, `${path33}.filePath`);
+  const symbol = parseStringOrUndefined(value.symbol, `${path33}.symbol`);
   if (filePath === void 0 && symbol === void 0) {
-    throw new Error(`${path31} must include filePath or symbol`);
+    throw new Error(`${path33} must include filePath or symbol`);
   }
   return {
     direction: value.direction,
@@ -16667,9 +17288,9 @@ function parseExpectedGraphNeighbor(value, path31) {
     ...symbol !== void 0 ? { symbol } : {}
   };
 }
-function parseExpected(input, path31) {
+function parseExpected(input, path33) {
   if (!isRecord3(input)) {
-    throw new Error(`${path31} must be an object`);
+    throw new Error(`${path33} must be an object`);
   }
   const filePathRaw = input.filePath;
   const acceptableFilesRaw = input.acceptableFiles;
@@ -16680,29 +17301,29 @@ function parseExpected(input, path31) {
   const recoveryExpectationRaw = input.recoveryExpectation;
   const gradedEvidenceRaw = input.gradedEvidence;
   const graphNeighborRaw = input.graphNeighbor;
-  const filePath = parseStringOrUndefined(filePathRaw, `${path31}.filePath`);
+  const filePath = parseStringOrUndefined(filePathRaw, `${path33}.filePath`);
   const acceptableFiles = isStringArray4(acceptableFilesRaw) ? acceptableFilesRaw : void 0;
-  const gradedEvidence = parseGradedEvidence(gradedEvidenceRaw, `${path31}.gradedEvidence`);
-  const graphNeighbor = parseExpectedGraphNeighbor(graphNeighborRaw, `${path31}.graphNeighbor`);
-  const expectedOutcome = parseExpectedOutcome(expectedOutcomeRaw, `${path31}.expectedOutcome`);
+  const gradedEvidence = parseGradedEvidence(gradedEvidenceRaw, `${path33}.gradedEvidence`);
+  const graphNeighbor = parseExpectedGraphNeighbor(graphNeighborRaw, `${path33}.graphNeighbor`);
+  const expectedOutcome = parseExpectedOutcome(expectedOutcomeRaw, `${path33}.expectedOutcome`);
   if (expectedOutcome !== "no-results" && !filePath && (!acceptableFiles || acceptableFiles.length === 0) && gradedEvidence.length === 0) {
     throw new Error(
-      `${path31} must include expected.filePath, expected.acceptableFiles, or expected.gradedEvidence`
+      `${path33} must include expected.filePath, expected.acceptableFiles, or expected.gradedEvidence`
     );
   }
   if (acceptableFilesRaw !== void 0 && !isStringArray4(acceptableFilesRaw)) {
-    throw new Error(`${path31}.acceptableFiles must be an array of strings`);
+    throw new Error(`${path33}.acceptableFiles must be an array of strings`);
   }
   if (symbolRaw !== void 0 && typeof symbolRaw !== "string") {
-    throw new Error(`${path31}.symbol must be a string when provided`);
+    throw new Error(`${path33}.symbol must be a string when provided`);
   }
   if (branchRaw !== void 0 && typeof branchRaw !== "string") {
-    throw new Error(`${path31}.branch must be a string when provided`);
+    throw new Error(`${path33}.branch must be a string when provided`);
   }
-  const expectedRoute = parseExpectedRoute(expectedRouteRaw, `${path31}.expectedRoute`);
+  const expectedRoute = parseExpectedRoute(expectedRouteRaw, `${path33}.expectedRoute`);
   const recoveryExpectation = parseRecoveryExpectation(
     recoveryExpectationRaw,
-    `${path31}.recoveryExpectation`
+    `${path33}.recoveryExpectation`
   );
   return {
     filePath,
@@ -16716,13 +17337,13 @@ function parseExpected(input, path31) {
     ...graphNeighbor !== void 0 ? { graphNeighbor } : {}
   };
 }
-function parseQueryLanguage(value, path31) {
-  return parseStringOrUndefined(value, path31);
+function parseQueryLanguage(value, path33) {
+  return parseStringOrUndefined(value, path33);
 }
 function parseQuery(input, index) {
-  const path31 = `queries[${index}]`;
+  const path33 = `queries[${index}]`;
   if (!isRecord3(input)) {
-    throw new Error(`${path31} must be an object`);
+    throw new Error(`${path33} must be an object`);
   }
   const id = input.id;
   const query = input.query;
@@ -16734,21 +17355,21 @@ function parseQuery(input, index) {
   const tags = input.tags;
   const args = input.args;
   if (typeof id !== "string" || id.trim().length === 0) {
-    throw new Error(`${path31}.id must be a non-empty string`);
+    throw new Error(`${path33}.id must be a non-empty string`);
   }
   if (typeof query !== "string" || query.trim().length === 0) {
-    throw new Error(`${path31}.query must be a non-empty string`);
+    throw new Error(`${path33}.query must be a non-empty string`);
   }
   return {
     id,
     query,
-    queryType: parseQueryType(queryType, `${path31}.queryType`),
-    retrievalMode: parseRetrievalMode(retrievalMode, `${path31}.retrievalMode`),
-    language: parseQueryLanguage(language, `${path31}.language`),
-    difficulty: parseQueryDifficulty(difficulty, `${path31}.difficulty`),
-    args: parseQueryArgs(args, `${path31}.args`),
-    tags: parseQueryTags(tags, `${path31}.tags`),
-    expected: parseExpected(expected, `${path31}.expected`)
+    queryType: parseQueryType(queryType, `${path33}.queryType`),
+    retrievalMode: parseRetrievalMode(retrievalMode, `${path33}.retrievalMode`),
+    language: parseQueryLanguage(language, `${path33}.language`),
+    difficulty: parseQueryDifficulty(difficulty, `${path33}.difficulty`),
+    args: parseQueryArgs(args, `${path33}.args`),
+    tags: parseQueryTags(tags, `${path33}.tags`),
+    expected: parseExpected(expected, `${path33}.expected`)
   };
 }
 function parseGoldenDataset(raw, sourceLabel) {
@@ -17088,12 +17709,13 @@ async function runEvaluation(options) {
           fileType: scope.fileType,
           directory: scope.directory
         }),
-        search: (searchQuery, limit, scope) => indexer.search(searchQuery, limit, {
+        search: (searchQuery, limit, scope, _trace, searchOptions) => indexer.search(searchQuery, limit, {
           metadataOnly: true,
           filterByBranch: !!query.expected.branch,
           definitionIntent: false,
           fileType: scope.fileType,
-          directory: scope.directory
+          directory: scope.directory,
+          prioritizeSourcePaths: searchOptions?.prioritizeSourcePaths
         })
       }) : void 0;
       const result = editContextResult?.results ?? contextResult?.details?.results ?? await indexer.search(query.query, 10, {
@@ -17715,7 +18337,7 @@ async function executeCallGraph(projectRoot, host, args) {
   return { text: formatCallGraphResult(await getCallGraphData(projectRoot, host, args)) };
 }
 async function executeCallGraphPath(projectRoot, host, args) {
-  const path31 = await getCallGraphPath(
+  const path33 = await getCallGraphPath(
     projectRoot,
     host,
     args.from,
@@ -17724,7 +18346,7 @@ async function executeCallGraphPath(projectRoot, host, args) {
     args.fromFilePath,
     args.toFilePath
   );
-  return { text: formatCallGraphPathResult(path31) };
+  return { text: formatCallGraphPathResult(path33) };
 }
 async function executeCodeCommunities(projectRoot, host, args) {
   const result = await getCodeCommunities(projectRoot, host, args);
@@ -17870,11 +18492,21 @@ var PI_TOOL_NAMES = [
   TOOL_NAME.PI_KNOWLEDGE_BASE_ADD,
   TOOL_NAME.PI_KNOWLEDGE_BASE_REMOVE
 ];
+var MCP_TOOL_NAMES = [
+  ...PORTABLE_TOOL_NAMES,
+  TOOL_NAME.ADD_KNOWLEDGE_BASE,
+  TOOL_NAME.LIST_KNOWLEDGE_BASES,
+  TOOL_NAME.REMOVE_KNOWLEDGE_BASE
+];
 
 // src/adapters/mcp/register-tools.ts
 function allowNullAsUndefined(schema) {
   return import_zod2.z.preprocess((value) => value === null ? void 0 : value, schema);
 }
+function knowledgeBaseResult(text) {
+  const content = [{ type: "text", text }];
+  return text.startsWith("Error: ") ? { content, isError: true } : { content };
+}
 function registerMcpTools(server, runtime) {
   server.tool(
     TOOL_NAME.CODEBASE_CONTEXT,
@@ -17935,7 +18567,8 @@ function registerMcpTools(server, runtime) {
       contextLines: allowNullAsUndefined(import_zod2.z.number().optional()).describe("Number of extra lines to include before/after each match (default: 0)"),
       blameAuthor: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter by git blame author name or email"),
       blameSha: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter by git blame commit SHA or prefix"),
-      blameSince: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter to chunks last changed on or after this date")
+      blameSince: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter to chunks last changed on or after this date"),
+      blameUntil: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter to chunks last changed on or before this date")
     },
     async (args) => {
       return searchCodebaseWithEffectiveness(runtime.projectRoot, runtime.host, "search", args.query, {
@@ -17946,7 +18579,8 @@ function registerMcpTools(server, runtime) {
         contextLines: args.contextLines,
         blameAuthor: args.blameAuthor,
         blameSha: args.blameSha,
-        blameSince: args.blameSince
+        blameSince: args.blameSince,
+        blameUntil: args.blameUntil
       }, (results) => {
         const text = results.length === 0 ? "No matching code found. Try a different query or run index_codebase first." : `Found ${results.length} results for "${args.query}":
 
@@ -17966,7 +18600,8 @@ ${formatSearchResults(results, "score")}`;
       chunkType: allowNullAsUndefined(import_zod2.z.enum(CHUNK_TYPES).optional()).describe("Filter by code chunk type"),
       blameAuthor: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter by git blame author name or email"),
       blameSha: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter by git blame commit SHA or prefix"),
-      blameSince: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter to chunks last changed on or after this date")
+      blameSince: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter to chunks last changed on or after this date"),
+      blameUntil: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter to chunks last changed on or before this date")
     },
     async (args) => {
       return searchCodebaseWithEffectiveness(runtime.projectRoot, runtime.host, "peek", args.query, {
@@ -17977,7 +18612,8 @@ ${formatSearchResults(results, "score")}`;
         metadataOnly: true,
         blameAuthor: args.blameAuthor,
         blameSha: args.blameSha,
-        blameSince: args.blameSince
+        blameSince: args.blameSince,
+        blameUntil: args.blameUntil
       }, (results) => {
         const text = results.length === 0 ? "No matching code found. Try a different query or run index_codebase first." : `Found ${results.length} locations for "${args.query}":
 
@@ -18054,7 +18690,9 @@ ${formatCodebasePeek(results)}`;
       fileType: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
       directory: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
       chunkType: allowNullAsUndefined(import_zod2.z.enum(CHUNK_TYPES).optional()).describe("Filter by code chunk type"),
-      excludeFile: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Exclude results from this file path")
+      excludeFile: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Exclude results from this file path"),
+      blameSince: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter to chunks last changed on or after this date"),
+      blameUntil: allowNullAsUndefined(import_zod2.z.string().optional()).describe("Filter to chunks last changed on or before this date")
     },
     async (args) => {
       const results = await findSimilarCode(runtime.projectRoot, runtime.host, args.code, {
@@ -18062,7 +18700,9 @@ ${formatCodebasePeek(results)}`;
         fileType: args.fileType,
         directory: args.directory,
         chunkType: args.chunkType,
-        excludeFile: args.excludeFile
+        excludeFile: args.excludeFile,
+        blameSince: args.blameSince,
+        blameUntil: args.blameUntil
       });
       if (results.length === 0) {
         return { content: [{ type: "text", text: "No similar code found. Try a different snippet or run index_codebase first." }] };
@@ -18166,6 +18806,37 @@ ${formatSearchResults(results)}` }] };
       return { content: [{ type: "text", text: result.text }] };
     }
   );
+  server.tool(
+    TOOL_NAME.ADD_KNOWLEDGE_BASE,
+    "Add a folder as a knowledge base to the semantic search index. The folder is indexed alongside the project code on the next index run. Provide an absolute path or a path relative to the project root. The path is written to the project-local host config of this MCP server (under the server project root), not to a user-global config, and the index is refreshed. Git blame metadata is collected only for files in the project git repo; knowledge-base files outside the repo remain searchable by content but have no blame. A knowledge base that appears in list_knowledge_bases but was inherited from a global config cannot be removed by this tool.",
+    {
+      path: import_zod2.z.string().describe("Path to the folder to add as a knowledge base (absolute or relative to the project root)")
+    },
+    async (args) => {
+      const result = addKnowledgeBase(runtime.projectRoot, runtime.host, args.path);
+      return knowledgeBaseResult(result);
+    }
+  );
+  server.tool(
+    TOOL_NAME.LIST_KNOWLEDGE_BASES,
+    "List the configured knowledge base folders that the index includes alongside the project code. The list is the union of project-local and user-global knowledge bases; each entry shows the resolved path and whether it exists.",
+    {},
+    async () => {
+      const result = listKnowledgeBases(runtime.projectRoot, runtime.host);
+      return knowledgeBaseResult(result);
+    }
+  );
+  server.tool(
+    TOOL_NAME.REMOVE_KNOWLEDGE_BASE,
+    "Remove a knowledge base folder from the semantic search index and refresh the index. The path must match a project-local configured path exactly. Knowledge bases inherited from a user-global config are not removable by this tool.",
+    {
+      path: import_zod2.z.string().describe("Path of the knowledge base to remove (must match a project-local configured path exactly)")
+    },
+    async (args) => {
+      const result = removeKnowledgeBase(runtime.projectRoot, runtime.host, args.path.trim());
+      return knowledgeBaseResult(result);
+    }
+  );
 }
 
 // src/adapters/mcp/server.ts
@@ -18303,7 +18974,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path31) => statMethod(path31, { bigint: true });
+      this._stat = (path33) => statMethod(path33, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -18328,8 +18999,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path31, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path31));
+          const { path: path33, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path33));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -18369,20 +19040,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path31, depth) {
+  async _exploreDir(path33, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path31, this._rdOptions);
+      files = await (0, import_promises.readdir)(path33, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path31 };
+    return { files, depth, path: path33 };
   }
-  async _formatEntry(dirent, path31) {
+  async _formatEntry(dirent, path33) {
     let entry;
     const basename8 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path31, basename8));
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path33, basename8));
       entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename8 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -18782,16 +19453,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path31, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path33, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path31);
-    emitRaw(rawEvent, evPath, { watchedPath: path31 });
-    if (evPath && path31 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path31, evPath), KEY_LISTENERS, sp.join(path31, evPath));
+    listener(path33);
+    emitRaw(rawEvent, evPath, { watchedPath: path33 });
+    if (evPath && path33 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path33, evPath), KEY_LISTENERS, sp.join(path33, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path31, {
+    return (0, import_node_fs.watch)(path33, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -18807,12 +19478,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path31, fullPath, options, handlers) => {
+var setFsWatchListener = (path33, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path31, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path33, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -18823,7 +19494,7 @@ var setFsWatchListener = (path31, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path31,
+      path33,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -18838,7 +19509,7 @@ var setFsWatchListener = (path31, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path31, "r");
+          const fd = await (0, import_promises2.open)(path33, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -18869,7 +19540,7 @@ var setFsWatchListener = (path31, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path31, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path33, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -18891,7 +19562,7 @@ var setFsWatchFileListener = (path31, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path31, curr));
+          foreach(cont.listeners, (listener2) => listener2(path33, curr));
         }
       })
     };
@@ -18921,13 +19592,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path31, listener) {
+  _watchWithNodeFs(path33, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path31);
-    const basename8 = sp.basename(path31);
+    const directory = sp.dirname(path33);
+    const basename8 = sp.basename(path33);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename8);
-    const absolutePath = sp.resolve(path31);
+    const absolutePath = sp.resolve(path33);
     const options = {
       persistent: opts.persistent
     };
@@ -18937,12 +19608,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path31, absolutePath, options, {
+      closer = setFsWatchFileListener(path33, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path31, absolutePath, options, {
+      closer = setFsWatchListener(path33, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -18964,7 +19635,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename8))
       return;
-    const listener = async (path31, newStats) => {
+    const listener = async (path33, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -18978,11 +19649,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path31);
+            this.fsw._closeFile(path33);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path31, closer2);
+              this.fsw._addPathCloser(path33, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -19014,7 +19685,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path31, item) {
+  async _handleSymlink(entry, directory, path33, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -19024,7 +19695,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path31);
+        linkPath = await (0, import_promises2.realpath)(path33);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -19034,12 +19705,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path31, entry.stats);
+          this.fsw._emit(EV.CHANGE, path33, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path31, entry.stats);
+        this.fsw._emit(EV.ADD, path33, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -19069,9 +19740,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path31 = sp.join(directory, item);
+      let path33 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path31, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path33, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -19080,11 +19751,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path31 = sp.join(dir, sp.relative(dir, path31));
-        this._addToNodeFs(path31, initialAdd, wh, depth + 1);
+        path33 = sp.join(dir, sp.relative(dir, path33));
+        this._addToNodeFs(path33, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve18, reject) => {
+    return new Promise((resolve20, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -19093,7 +19764,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve18(void 0);
+        resolve20(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -19150,13 +19821,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path31, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path33, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path31) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path33) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path31);
+    const wh = this.fsw._getWatchHelpers(path33);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -19172,8 +19843,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path31);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path31) : path31;
+        const absPath = sp.resolve(path33);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path33) : path33;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -19183,29 +19854,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path31) : path31;
+        const targetPath = follow ? await (0, import_promises2.realpath)(path33) : path33;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path31, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path33, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path31), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path33), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path31, closer);
+        this.fsw._addPathCloser(path33, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path31;
+        return path33;
       }
     }
   }
@@ -19237,35 +19908,35 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative12 = sp2.relative(matcher.path, string);
-        if (!relative12) {
+        const relative14 = sp2.relative(matcher.path, string);
+        if (!relative14) {
           return false;
         }
-        return !relative12.startsWith("..") && !sp2.isAbsolute(relative12);
+        return !relative14.startsWith("..") && !sp2.isAbsolute(relative14);
       }
       return false;
     };
   }
   return () => false;
 }
-function normalizePath3(path31) {
-  if (typeof path31 !== "string")
+function normalizePath3(path33) {
+  if (typeof path33 !== "string")
     throw new Error("string expected");
-  path31 = sp2.normalize(path31);
-  path31 = path31.replace(/\\/g, "/");
+  path33 = sp2.normalize(path33);
+  path33 = path33.replace(/\\/g, "/");
   let prepend = false;
-  if (path31.startsWith("//"))
+  if (path33.startsWith("//"))
     prepend = true;
-  path31 = path31.replace(DOUBLE_SLASH_RE, "/");
+  path33 = path33.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path31 = "/" + path31;
-  return path31;
+    path33 = "/" + path33;
+  return path33;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path31 = normalizePath3(testString);
+  const path33 = normalizePath3(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path31, stats)) {
+    if (pattern(path33, stats)) {
       return true;
     }
   }
@@ -19303,19 +19974,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path31) => toUnix(sp2.normalize(toUnix(path31)));
-var normalizeIgnored = (cwd = "") => (path31) => {
-  if (typeof path31 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path31) ? path31 : sp2.join(cwd, path31));
+var normalizePathToUnix = (path33) => toUnix(sp2.normalize(toUnix(path33)));
+var normalizeIgnored = (cwd = "") => (path33) => {
+  if (typeof path33 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path33) ? path33 : sp2.join(cwd, path33));
   } else {
-    return path31;
+    return path33;
   }
 };
-var getAbsolutePath = (path31, cwd) => {
-  if (sp2.isAbsolute(path31)) {
-    return path31;
+var getAbsolutePath = (path33, cwd) => {
+  if (sp2.isAbsolute(path33)) {
+    return path33;
   }
-  return sp2.join(cwd, path31);
+  return sp2.join(cwd, path33);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -19380,10 +20051,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path31, follow, fsw) {
+  constructor(path33, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path31;
-    this.path = path31 = path31.replace(REPLACER_RE, "");
+    const watchPath = path33;
+    this.path = path33 = path33.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -19523,20 +20194,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path31) => {
-        const absPath = getAbsolutePath(path31, cwd);
+      paths = paths.map((path33) => {
+        const absPath = getAbsolutePath(path33, cwd);
         return absPath;
       });
     }
-    paths.forEach((path31) => {
-      this._removeIgnoredPath(path31);
+    paths.forEach((path33) => {
+      this._removeIgnoredPath(path33);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path31) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path31, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path33) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path33, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -19558,17 +20229,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path31) => {
-      if (!sp2.isAbsolute(path31) && !this._closers.has(path31)) {
+    paths.forEach((path33) => {
+      if (!sp2.isAbsolute(path33) && !this._closers.has(path33)) {
         if (cwd)
-          path31 = sp2.join(cwd, path31);
-        path31 = sp2.resolve(path31);
+          path33 = sp2.join(cwd, path33);
+        path33 = sp2.resolve(path33);
       }
-      this._closePath(path31);
-      this._addIgnoredPath(path31);
-      if (this._watched.has(path31)) {
+      this._closePath(path33);
+      this._addIgnoredPath(path33);
+      if (this._watched.has(path33)) {
         this._addIgnoredPath({
-          path: path31,
+          path: path33,
           recursive: true
         });
       }
@@ -19632,38 +20303,38 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path31, stats) {
+  async _emit(event, path33, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path31 = sp2.normalize(path31);
+      path33 = sp2.normalize(path33);
     if (opts.cwd)
-      path31 = sp2.relative(opts.cwd, path31);
-    const args = [path31];
+      path33 = sp2.relative(opts.cwd, path33);
+    const args = [path33];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path31))) {
+    if (awf && (pw = this._pendingWrites.get(path33))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path31, [event, ...args]);
+        this._pendingUnlinks.set(path33, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path32) => {
+          this._pendingUnlinks.forEach((entry, path34) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path32);
+            this._pendingUnlinks.delete(path34);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path31)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path33)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path31);
+        this._pendingUnlinks.delete(path33);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -19681,16 +20352,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path31, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path33, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path31, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path33, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path31) : path31;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path33) : path33;
       let stats2;
       try {
         stats2 = await (0, import_promises3.stat)(fullPath);
@@ -19721,23 +20392,23 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path31, timeout) {
+  _throttle(actionType, path33, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path31);
+    const actionPath = action.get(path33);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path31);
+      const item = action.get(path33);
       const count = item ? item.count : 0;
-      action.delete(path31);
+      action.delete(path33);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -19745,7 +20416,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path31, thr);
+    action.set(path33, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -19759,44 +20430,44 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path31, threshold, event, awfEmit) {
+  _awaitWriteFinish(path33, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path31;
-    if (this.options.cwd && !sp2.isAbsolute(path31)) {
-      fullPath = sp2.join(this.options.cwd, path31);
+    let fullPath = path33;
+    if (this.options.cwd && !sp2.isAbsolute(path33)) {
+      fullPath = sp2.join(this.options.cwd, path33);
     }
     const now2 = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path31)) {
+        if (err || !writes.has(path33)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now3 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path31).lastChange = now3;
+          writes.get(path33).lastChange = now3;
         }
-        const pw = writes.get(path31);
+        const pw = writes.get(path33);
         const df = now3 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path31);
+          writes.delete(path33);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path31)) {
-      writes.set(path31, {
+    if (!writes.has(path33)) {
+      writes.set(path33, {
         lastChange: now2,
         cancelWait: () => {
-          writes.delete(path31);
+          writes.delete(path33);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -19807,8 +20478,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path31, stats) {
-    if (this.options.atomic && DOT_RE.test(path31))
+  _isIgnored(path33, stats) {
+    if (this.options.atomic && DOT_RE.test(path33))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -19818,17 +20489,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path31, stats);
+    return this._userIgnored(path33, stats);
   }
-  _isntIgnored(path31, stat4) {
-    return !this._isIgnored(path31, stat4);
+  _isntIgnored(path33, stat5) {
+    return !this._isIgnored(path33, stat5);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path31) {
-    return new WatchHelper(path31, this.options.followSymlinks, this);
+  _getWatchHelpers(path33) {
+    return new WatchHelper(path33, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -19860,63 +20531,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path31 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path31);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path31) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path31, 100))
+    const path33 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path33);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path33) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path33, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path31);
+    const wp = this._getWatchedDir(path33);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path31, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path33, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path31;
+    let relPath = path33;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path31);
+      relPath = sp2.relative(this.options.cwd, path33);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path31);
+    this._watched.delete(path33);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path31))
-      this._emit(eventName, path31);
-    this._closePath(path31);
+    if (wasTracked && !this._isIgnored(path33))
+      this._emit(eventName, path33);
+    this._closePath(path33);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path31) {
-    this._closeFile(path31);
-    const dir = sp2.dirname(path31);
-    this._getWatchedDir(dir).remove(sp2.basename(path31));
+  _closePath(path33) {
+    this._closeFile(path33);
+    const dir = sp2.dirname(path33);
+    this._getWatchedDir(dir).remove(sp2.basename(path33));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path31) {
-    const closers = this._closers.get(path31);
+  _closeFile(path33) {
+    const closers = this._closers.get(path33);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path31);
+    this._closers.delete(path33);
   }
-  _addPathCloser(path31, closer) {
+  _addPathCloser(path33, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path31);
+    let list = this._closers.get(path33);
     if (!list) {
       list = [];
-      this._closers.set(path31, list);
+      this._closers.set(path33, list);
     }
     list.push(closer);
   }
@@ -19946,12 +20617,291 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/file-watcher.ts
+var path28 = __toESM(require("path"), 1);
+
+// src/watcher/native-recursive-watcher.ts
+var import_node_fs3 = require("fs");
 var path26 = __toESM(require("path"), 1);
+var NativeRecursiveWatcher = class {
+  constructor(root, onChange, options = {}) {
+    this.root = root;
+    this.onChange = onChange;
+    this.watchFactory = options.watchFactory ?? this.defaultWatchFactory;
+    this.onError = options.onError;
+  }
+  root;
+  onChange;
+  watcher = null;
+  listenerToken = 0;
+  watchFactory;
+  onError;
+  start() {
+    if (this.watcher) return;
+    const token = ++this.listenerToken;
+    const listener = (_eventType, filename) => {
+      if (this.watcher === null || this.listenerToken !== token) return;
+      const absolutePath = this.toAbsolutePath(filename);
+      const nextResult = this.onChange(absolutePath);
+      if (nextResult instanceof Promise) {
+        void nextResult.catch((error) => {
+          console.error("[codebase-index] Error handling native watcher event:", error);
+        });
+      }
+    };
+    const watcher = this.watchFactory(this.root, listener, {
+      persistent: true,
+      recursive: true
+    });
+    watcher.on?.("error", (error) => {
+      if (this.watcher === watcher && this.listenerToken === token) {
+        this.onError?.(error);
+      }
+    });
+    this.watcher = watcher;
+  }
+  async stop() {
+    const watcher = this.watcher;
+    this.watcher = null;
+    this.listenerToken += 1;
+    if (!watcher) return;
+    await watcher.close();
+  }
+  toAbsolutePath(filename) {
+    if (filename == null) return null;
+    const normalizedFilename = typeof filename === "string" ? filename : filename.toString();
+    const absolutePath = path26.resolve(this.root, normalizedFilename);
+    const relativePath = path26.relative(this.root, absolutePath);
+    const outsideRoot = relativePath === ".." || relativePath.startsWith(`..${path26.sep}`) || path26.isAbsolute(relativePath);
+    return outsideRoot ? null : absolutePath;
+  }
+  defaultWatchFactory = (root, listener, options) => (0, import_node_fs3.watch)(root, options, listener);
+};
+
+// src/watcher/snapshot.ts
+var fsPromises4 = __toESM(require("fs/promises"), 1);
+var path27 = __toESM(require("path"), 1);
+async function buildFileSnapshotScan(projectRoot, config, configPaths = []) {
+  const normalizedProjectRoot = path27.resolve(projectRoot);
+  const ignoreFilter = createIgnoreFilter(normalizedProjectRoot);
+  const includePatterns = [...config.include, ...config.additionalInclude ?? []];
+  const maxDepth = config.indexing?.maxDepth ?? -1;
+  const snapshot = /* @__PURE__ */ new Map();
+  const unreadablePrefixes = /* @__PURE__ */ new Set();
+  const includeFile = async (filePath) => {
+    const normalizedPath3 = path27.resolve(filePath);
+    if (!shouldIncludeFile(normalizedPath3, normalizedProjectRoot, includePatterns, config.exclude, ignoreFilter)) return;
+    const stat5 = await readStatIfFile(normalizedPath3, unreadablePrefixes);
+    if (stat5) snapshot.set(normalizedPath3, { size: stat5.size, mtimeMs: stat5.mtimeMs });
+  };
+  const walk = async (directoryPath, depth) => {
+    let entries;
+    try {
+      entries = await fsPromises4.readdir(directoryPath, { withFileTypes: true });
+    } catch (error) {
+      if (isMissingFsError(error)) return;
+      if (isPermissionFsError(error)) {
+        unreadablePrefixes.add(path27.resolve(directoryPath));
+        return;
+      }
+      throw error;
+    }
+    for (const entry of entries) {
+      const fullPath = path27.join(directoryPath, entry.name);
+      const relativePath = path27.relative(normalizedProjectRoot, fullPath);
+      if (entry.isDirectory()) {
+        if (hasFilteredPathSegment(relativePath, path27.sep) || isRestrictedDirectory(relativePath, path27.sep)) continue;
+        if (ignoreFilter.ignores(relativePath)) continue;
+        if (maxDepth === -1 || depth < maxDepth) await walk(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        await includeFile(fullPath);
+      }
+    }
+  };
+  await walk(normalizedProjectRoot, 0);
+  await includeExplicitConfigPaths(snapshot, unreadablePrefixes, configPaths);
+  return { entries: snapshot, unreadablePrefixes };
+}
+async function buildFileSnapshotForPathScan(projectRoot, config, configPaths, targetPath) {
+  const normalizedProjectRoot = path27.resolve(projectRoot);
+  const normalizedTargetPath = path27.resolve(targetPath);
+  if (!isWithinPath(normalizedProjectRoot, normalizedTargetPath)) {
+    return { entries: /* @__PURE__ */ new Map(), unreadablePrefixes: /* @__PURE__ */ new Set() };
+  }
+  const ignoreFilter = createIgnoreFilter(normalizedProjectRoot);
+  const includePatterns = [...config.include, ...config.additionalInclude ?? []];
+  const maxDepth = config.indexing?.maxDepth ?? -1;
+  const explicitConfigPaths = new Set(configPaths.map((configPath) => path27.resolve(configPath)));
+  const snapshot = /* @__PURE__ */ new Map();
+  const unreadablePrefixes = /* @__PURE__ */ new Set();
+  const includeFile = async (filePath) => {
+    const normalizedPath3 = path27.resolve(filePath);
+    if (!explicitConfigPaths.has(normalizedPath3) && !shouldIncludeFile(
+      normalizedPath3,
+      normalizedProjectRoot,
+      includePatterns,
+      config.exclude,
+      ignoreFilter
+    )) return;
+    const stat5 = await readStatIfFile(normalizedPath3, unreadablePrefixes);
+    if (stat5) snapshot.set(normalizedPath3, { size: stat5.size, mtimeMs: stat5.mtimeMs });
+  };
+  const walk = async (directoryPath, depth) => {
+    let entries;
+    try {
+      entries = await fsPromises4.readdir(directoryPath, { withFileTypes: true });
+    } catch (error) {
+      if (isMissingFsError(error)) return;
+      if (isPermissionFsError(error)) {
+        unreadablePrefixes.add(path27.resolve(directoryPath));
+        return;
+      }
+      throw error;
+    }
+    for (const entry of entries) {
+      const fullPath = path27.join(directoryPath, entry.name);
+      const relativePath = path27.relative(normalizedProjectRoot, fullPath);
+      if (entry.isDirectory()) {
+        if (hasFilteredPathSegment(relativePath, path27.sep) || isRestrictedDirectory(relativePath, path27.sep)) continue;
+        if (ignoreFilter.ignores(relativePath)) continue;
+        if (maxDepth === -1 || depth < maxDepth) await walk(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        await includeFile(fullPath);
+      }
+    }
+  };
+  const targetStat = await readStatIfFile(normalizedTargetPath, unreadablePrefixes);
+  if (targetStat) await includeFile(normalizedTargetPath);
+  else await walk(normalizedTargetPath, 0);
+  await includeExplicitConfigPathsInPath(snapshot, unreadablePrefixes, configPaths, normalizedTargetPath);
+  return { entries: snapshot, unreadablePrefixes };
+}
+function completeFileSnapshot(previous, scan) {
+  const completed = new Map(scan.entries);
+  for (const unreadablePrefix of scan.unreadablePrefixes) {
+    for (const [entryPath, entry] of previous) {
+      if (isWithinPath(unreadablePrefix, entryPath) && !completed.has(entryPath)) completed.set(entryPath, entry);
+    }
+  }
+  return completed;
+}
+async function includeExplicitConfigPaths(snapshot, unreadablePrefixes, configPaths) {
+  for (const configPath of [...new Set(configPaths.map((value) => path27.resolve(value)))]) {
+    if (snapshot.has(configPath)) continue;
+    const stat5 = await readStatIfFile(configPath, unreadablePrefixes);
+    if (stat5) snapshot.set(configPath, { size: stat5.size, mtimeMs: stat5.mtimeMs });
+  }
+}
+async function includeExplicitConfigPathsInPath(snapshot, unreadablePrefixes, configPaths, targetPath) {
+  await includeExplicitConfigPaths(
+    snapshot,
+    unreadablePrefixes,
+    configPaths.filter((configPath) => isWithinPath(targetPath, path27.resolve(configPath)))
+  );
+}
+function isWithinPath(parentPath, childPath) {
+  const relativePath = path27.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith(`..${path27.sep}`) && relativePath !== ".." && !path27.isAbsolute(relativePath);
+}
+async function readStatIfFile(filePath, unreadablePrefixes) {
+  try {
+    const stat5 = await fsPromises4.stat(filePath);
+    return stat5.isFile() ? stat5 : null;
+  } catch (error) {
+    if (isMissingFsError(error)) return null;
+    if (isPermissionFsError(error)) {
+      unreadablePrefixes.add(path27.resolve(filePath));
+      return null;
+    }
+    throw error;
+  }
+}
+function isMissingFsError(error) {
+  return error instanceof Error && ["ENOENT", "ENOTDIR"].includes(error.code ?? "");
+}
+function isPermissionFsError(error) {
+  return error instanceof Error && ["EACCES", "EPERM"].includes(error.code ?? "");
+}
+var diffTypeOrder = { add: 0, change: 1, unlink: 2 };
+function diffFileSnapshots(previous, current, forcedChanges = /* @__PURE__ */ new Set()) {
+  const changes = [];
+  for (const [filePath, previousEntry] of previous) {
+    const currentEntry = current.get(filePath);
+    if (!currentEntry) changes.push({ type: "unlink", path: filePath });
+    else if (forcedChanges.has(filePath) || currentEntry.size !== previousEntry.size || currentEntry.mtimeMs !== previousEntry.mtimeMs) {
+      changes.push({ type: "change", path: filePath });
+    }
+  }
+  for (const [filePath] of current) {
+    if (!previous.has(filePath)) changes.push({ type: "add", path: filePath });
+  }
+  return changes.sort((left, right) => left.path.localeCompare(right.path) || diffTypeOrder[left.type] - diffTypeOrder[right.type]);
+}
+
+// src/watcher/snapshot-reconciler.ts
+var FileSnapshotReconciler = class {
+  constructor(projectRoot, config, configPaths) {
+    this.projectRoot = projectRoot;
+    this.config = config;
+    this.configPaths = configPaths;
+  }
+  projectRoot;
+  config;
+  configPaths;
+  snapshot = null;
+  reconciliationTail = Promise.resolve();
+  async initialize() {
+    this.snapshot = (await buildFileSnapshotScan(this.projectRoot, this.config, this.configPaths)).entries;
+  }
+  async reconcile(invalidations = []) {
+    if (this.snapshot === null) {
+      throw new Error("FileSnapshotReconciler is not initialized. Call initialize() before reconcile().");
+    }
+    const reconciliation = this.reconciliationTail.then(async () => {
+      const previousSnapshot = this.snapshot;
+      if (previousSnapshot === null) {
+        throw new Error("FileSnapshotReconciler is not initialized. Call initialize() before reconcile().");
+      }
+      const normalizedInvalidations = invalidations.map((invalidation) => typeof invalidation === "string" || invalidation === null ? { path: invalidation, forceChange: false } : { path: invalidation.path, forceChange: invalidation.forceChange === true });
+      const scopedPaths = normalizedInvalidations.map((invalidation) => invalidation.path).filter((filePath) => filePath !== null);
+      const scan = scopedPaths.length === 0 || scopedPaths.length !== normalizedInvalidations.length ? await buildFileSnapshotScan(this.projectRoot, this.config, this.configPaths) : await this.reconcilePaths(previousSnapshot, scopedPaths);
+      const nextSnapshot = completeFileSnapshot(previousSnapshot, scan);
+      const forcedChanges = new Set(normalizedInvalidations.filter((invalidation) => invalidation.path !== null && invalidation.forceChange).map((invalidation) => invalidation.path));
+      const changes = diffFileSnapshots(previousSnapshot, nextSnapshot, forcedChanges);
+      this.snapshot = nextSnapshot;
+      return changes;
+    });
+    this.reconciliationTail = reconciliation.then(() => void 0, () => void 0);
+    return reconciliation;
+  }
+  async reconcilePaths(previousSnapshot, invalidatedPaths) {
+    const scopes = this.getScopes(invalidatedPaths);
+    const entries = new Map(previousSnapshot);
+    const unreadablePrefixes = /* @__PURE__ */ new Set();
+    for (const scope of scopes) {
+      for (const previousPath of entries.keys()) {
+        if (isWithinPath(scope, previousPath)) entries.delete(previousPath);
+      }
+      const scopedScan = await buildFileSnapshotForPathScan(this.projectRoot, this.config, this.configPaths, scope);
+      for (const [filePath, entry] of scopedScan.entries) entries.set(filePath, entry);
+      for (const unreadablePrefix of scopedScan.unreadablePrefixes) unreadablePrefixes.add(unreadablePrefix);
+    }
+    return { entries, unreadablePrefixes };
+  }
+  getScopes(invalidatedPaths) {
+    const uniquePaths = [...new Set(invalidatedPaths)].sort((left, right) => left.length - right.length);
+    return uniquePaths.filter((candidate, index) => !uniquePaths.slice(0, index).some(
+      (ancestor) => isWithinPath(ancestor, candidate)
+    ));
+  }
+};
+
+// src/watcher/file-watcher.ts
 var FileWatcher = class {
   watcher = null;
   projectRoot;
   config;
   configPath;
+  backend;
   projectConfigPaths;
   pendingChanges = /* @__PURE__ */ new Map();
   debounceTimer = null;
@@ -19961,44 +20911,74 @@ var FileWatcher = class {
   resolveReady = null;
   pollingFallbackAttempted = false;
   pendingClose = null;
+  startupReadySignals = 1;
+  nativeWatcher = null;
+  nativeReconciler = null;
+  nativeSetupGeneration = 0;
+  nativeStarting = false;
+  nativeInitializing = false;
+  nativeReconcileTimer = null;
+  nativeInvalidatedPaths = /* @__PURE__ */ new Map();
+  configPathStates = /* @__PURE__ */ new Map();
   constructor(projectRoot, config, host, options = {}) {
     this.projectRoot = projectRoot;
     this.config = config;
+    this.backend = options.backend ?? "auto";
     this.configPath = options.configPath;
     this.projectConfigPaths = options.configPath ? [options.configPath] : getProjectConfigCandidatePaths(projectRoot, host);
   }
   start(handler) {
-    if (this.watcher) {
+    if (this.watcher || this.nativeWatcher || this.nativeStarting) {
       return;
     }
     this.onChanges = handler;
     this.pollingFallbackAttempted = false;
     this.resetReady();
+    if (this.shouldUseNativeWatcher()) {
+      if (this.hasExternalConfigWatchTarget()) {
+        this.setStartupReadySignals(2);
+        this.startExternalConfigWatcher();
+      }
+      this.nativeStarting = true;
+      void this.createNativeWatcher();
+      return;
+    }
     this.createWatcher();
   }
   resetReady() {
-    this.readyPromise = new Promise((resolve18) => {
-      this.resolveReady = resolve18;
+    this.readyPromise = new Promise((resolve20) => {
+      this.resolveReady = resolve20;
     });
+    this.startupReadySignals = 1;
   }
-  createWatcher(usePolling = false) {
-    const ignoreFilter = createIgnoreFilter(this.projectRoot);
-    let watchTargets = this.projectRoot;
-    if (this.configPath) {
-      watchTargets = [this.projectRoot, this.configPath];
-    } else {
-      const externalConfigTargets = this.projectConfigPaths.filter((projectConfigPath) => {
-        const relativeConfigPath = path26.relative(this.projectRoot, projectConfigPath);
-        return this.isOutsideProjectPath(relativeConfigPath);
-      }).map((projectConfigPath) => (0, import_fs19.existsSync)(projectConfigPath) ? projectConfigPath : this.getNearestExistingDirectory(path26.dirname(projectConfigPath)));
-      const uniqueExternalConfigTargets = [...new Set(externalConfigTargets)];
-      if (uniqueExternalConfigTargets.length > 0) {
-        watchTargets = [this.projectRoot, ...uniqueExternalConfigTargets];
-      }
+  setStartupReadySignals(expectedSignals) {
+    if (!this.readyPromise) {
+      return;
     }
+    this.startupReadySignals = Math.max(0, expectedSignals);
+  }
+  reportStartupReadySignal() {
+    if (!this.readyPromise || !this.resolveReady) {
+      return;
+    }
+    if (this.startupReadySignals <= 0) {
+      return;
+    }
+    this.startupReadySignals -= 1;
+    if (this.startupReadySignals !== 0) {
+      return;
+    }
+    this.resolveReady();
+    this.resolveReady = null;
+  }
+  createWatcher(watchTargets, usePolling = false, reportsStartupReady = true) {
+    let reportedStartupReady = false;
+    this.configPathStates = this.getConfigPathStates();
+    const ignoreFilter = createIgnoreFilter(this.projectRoot);
+    const resolvedWatchTargets = watchTargets ?? this.getFullChokidarWatchTargets();
     const watcherOptions = {
       ignored: (filePath) => {
-        const relativePath = path26.relative(this.projectRoot, filePath);
+        const relativePath = path28.relative(this.projectRoot, filePath);
         if (!relativePath) return false;
         if (this.isProjectConfigPathOrAncestor(relativePath)) {
           return false;
@@ -20006,10 +20986,10 @@ var FileWatcher = class {
         if (this.isOutsideProjectPath(relativePath)) {
           return true;
         }
-        if (hasFilteredPathSegment(relativePath, path26.sep)) {
+        if (hasFilteredPathSegment(relativePath, path28.sep)) {
           return true;
         }
-        if (isRestrictedDirectory(relativePath, path26.sep)) {
+        if (isRestrictedDirectory(relativePath, path28.sep)) {
           return true;
         }
         if (ignoreFilter.ignores(relativePath)) {
@@ -20042,10 +21022,13 @@ var FileWatcher = class {
       watcher = new FSWatcher(watcherOptions);
     }
     this.watcher = watcher;
-    watcher.once("ready", () => {
+    watcher.on("ready", () => {
       if (this.watcher !== watcher) return;
-      this.resolveReady?.();
-      this.resolveReady = null;
+      this.reconcileConfigPathStates();
+      if (reportsStartupReady) {
+        this.reportStartupReadySignal();
+        reportedStartupReady = true;
+      }
     });
     watcher.on("error", (error) => {
       const err = error instanceof Error ? error : null;
@@ -20059,10 +21042,13 @@ var FileWatcher = class {
           console.error("[codebase-index] Failed to close exhausted file watcher:", closeError);
         });
         if (this.onChanges) {
+          const replacementReportsStartupReady = reportsStartupReady || reportedStartupReady;
           if (!this.resolveReady) {
             this.resetReady();
+          } else if (reportedStartupReady) {
+            this.startupReadySignals += 1;
           }
-          this.createWatcher(true);
+          this.createWatcher(resolvedWatchTargets, true, replacementReportsStartupReady);
         } else {
           this.watcher = null;
         }
@@ -20073,13 +21059,166 @@ var FileWatcher = class {
     watcher.on("add", (filePath) => this.handleChange(watcher, "add", filePath));
     watcher.on("change", (filePath) => this.handleChange(watcher, "change", filePath));
     watcher.on("unlink", (filePath) => this.handleChange(watcher, "unlink", filePath));
-    watcher.add(watchTargets);
+    watcher.add(resolvedWatchTargets);
+  }
+  shouldUseNativeWatcher() {
+    if (this.backend === "chokidar") {
+      return false;
+    }
+    return true;
+  }
+  getFullChokidarWatchTargets() {
+    if (this.configPath) {
+      return [this.projectRoot, this.configPath];
+    }
+    const externalConfigTargets = this.getExternalConfigWatchTargets();
+    if (externalConfigTargets.length === 0) {
+      return this.projectRoot;
+    }
+    return [this.projectRoot, ...externalConfigTargets];
+  }
+  getExternalConfigWatchTargets() {
+    return [...new Set(
+      this.projectConfigPaths.filter((projectConfigPath) => {
+        const relativeConfigPath = path28.relative(this.projectRoot, projectConfigPath);
+        return this.isOutsideProjectPath(relativeConfigPath);
+      }).map((projectConfigPath) => {
+        if ((0, import_fs19.existsSync)(projectConfigPath)) {
+          return projectConfigPath;
+        }
+        return this.getNearestExistingDirectory(path28.dirname(projectConfigPath));
+      })
+    )];
+  }
+  hasExternalConfigWatchTarget() {
+    return this.getExternalConfigWatchTargets().length > 0;
+  }
+  startExternalConfigWatcher(usePolling = false) {
+    const externalTargets = this.getExternalConfigWatchTargets();
+    if (externalTargets.length === 0) {
+      return;
+    }
+    this.createWatcher(externalTargets, usePolling);
+  }
+  async createNativeWatcher() {
+    const generation = ++this.nativeSetupGeneration;
+    const reconciler = new FileSnapshotReconciler(this.projectRoot, this.config, this.projectConfigPaths);
+    const watcher = new NativeRecursiveWatcher(
+      this.projectRoot,
+      (filePath) => this.scheduleNativeReconciliation(generation, filePath),
+      { onError: (error) => void this.fallbackFromNativeWatcher(generation, error) }
+    );
+    this.nativeReconciler = reconciler;
+    this.nativeWatcher = watcher;
+    this.nativeInitializing = true;
+    try {
+      watcher.start();
+      if (!this.isCurrentNativeSetup(generation)) {
+        await watcher.stop();
+        return;
+      }
+      await reconciler.initialize();
+      if (!this.isCurrentNativeSetup(generation) || this.nativeWatcher !== watcher) {
+        await watcher.stop();
+        return;
+      }
+      this.nativeStarting = false;
+      this.nativeInitializing = false;
+      await this.reconcileNativeWatcherWithPendingInvalidations(generation);
+      this.reportStartupReadySignal();
+    } catch (error) {
+      if (!this.isCurrentNativeSetup(generation)) return;
+      this.nativeInitializing = false;
+      if (this.nativeWatcher) {
+        await this.fallbackFromNativeWatcher(generation, error);
+        return;
+      }
+      this.nativeStarting = false;
+      const externalWatcher = this.watcher;
+      this.watcher = null;
+      this.nativeReconciler = null;
+      await externalWatcher?.close();
+      console.warn("[codebase-index] Native recursive watcher unavailable; using Chokidar fallback.", error);
+      this.setStartupReadySignals(1);
+      this.createWatcher();
+    }
+  }
+  isCurrentNativeSetup(generation) {
+    return this.nativeSetupGeneration === generation && this.onChanges !== null;
+  }
+  scheduleNativeReconciliation(generation, filePath) {
+    if (!this.isCurrentNativeSetup(generation)) return;
+    const requiresFullReconciliation = filePath === path28.join(this.projectRoot, ".gitignore");
+    const invalidatedPath = requiresFullReconciliation ? null : filePath;
+    this.nativeInvalidatedPaths.set(invalidatedPath, invalidatedPath !== null);
+    if (this.nativeReconcileTimer) {
+      clearTimeout(this.nativeReconcileTimer);
+    }
+    this.nativeReconcileTimer = setTimeout(() => {
+      this.nativeReconcileTimer = null;
+      void this.reconcileNativeWatcherFromQueue(generation);
+    }, 100);
+  }
+  reconcileNativeWatcherFromQueue(generation) {
+    if (!this.isCurrentNativeSetup(generation) || this.nativeInitializing) return;
+    const invalidatedPaths = this.popNativeInvalidations();
+    if (invalidatedPaths.length === 0) return;
+    void this.reconcileNativeWatcher(generation, invalidatedPaths);
+  }
+  async reconcileNativeWatcher(generation, invalidatedPaths) {
+    if (!this.isCurrentNativeSetup(generation) || !this.nativeReconciler) return;
+    try {
+      const reconciler = this.nativeReconciler;
+      const changes = await reconciler.reconcile(invalidatedPaths);
+      if (!this.isCurrentNativeSetup(generation) || this.nativeReconciler !== reconciler) return;
+      this.recordChanges(changes);
+    } catch (error) {
+      await this.fallbackFromNativeWatcher(generation, error);
+    }
+  }
+  async reconcileNativeWatcherWithPendingInvalidations(generation) {
+    const invalidatedPaths = this.popNativeInvalidations();
+    if (invalidatedPaths.length === 0) return;
+    await this.reconcileNativeWatcher(generation, invalidatedPaths);
+  }
+  popNativeInvalidations() {
+    if (this.nativeInvalidatedPaths.size === 0) return [];
+    const invalidations = [...this.nativeInvalidatedPaths].map(([invalidatedPath, forceChange]) => ({
+      path: invalidatedPath,
+      forceChange
+    }));
+    this.nativeInvalidatedPaths.clear();
+    return invalidations;
+  }
+  async fallbackFromNativeWatcher(generation, error) {
+    if (!this.isCurrentNativeSetup(generation)) return;
+    const watcher = this.nativeWatcher;
+    const externalWatcher = this.watcher;
+    this.nativeWatcher = null;
+    this.watcher = null;
+    this.nativeReconciler = null;
+    this.nativeStarting = false;
+    this.nativeInitializing = false;
+    this.nativeSetupGeneration += 1;
+    if (this.nativeReconcileTimer) {
+      clearTimeout(this.nativeReconcileTimer);
+      this.nativeReconcileTimer = null;
+    }
+    this.nativeInvalidatedPaths.clear();
+    this.setStartupReadySignals(1);
+    console.warn("[codebase-index] Native recursive watcher failed; using Chokidar fallback.", error);
+    await watcher?.stop();
+    await externalWatcher?.close();
+    if (this.onChanges) {
+      this.createWatcher();
+    }
   }
   handleChange(watcher, type, filePath) {
     if (this.watcher !== watcher) {
       return;
     }
     if (this.isProjectConfigPath(filePath)) {
+      this.updateConfigPathState(filePath);
       this.pendingChanges.set(filePath, type);
       this.scheduleFlush();
       return;
@@ -20094,27 +21233,33 @@ var FileWatcher = class {
     )) {
       return;
     }
-    this.pendingChanges.set(filePath, type);
+    this.recordChanges([{ path: filePath, type }]);
+  }
+  recordChanges(changes) {
+    if (changes.length === 0) return;
+    for (const change of changes) {
+      this.pendingChanges.set(change.path, change.type);
+    }
     this.scheduleFlush();
   }
   isProjectConfigPath(filePath) {
-    const relativePath = path26.relative(this.projectRoot, filePath);
-    const normalizedRelativePath = path26.normalize(relativePath);
+    const relativePath = path28.relative(this.projectRoot, filePath);
+    const normalizedRelativePath = path28.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some((configPath) => configPath === normalizedRelativePath);
   }
   isProjectConfigPathOrAncestor(relativePath) {
-    const normalizedRelativePath = path26.normalize(relativePath);
+    const normalizedRelativePath = path28.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some(
-      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path26.sep}`)
+      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path28.sep}`)
     );
   }
   isOutsideProjectPath(relativePath) {
-    return relativePath === ".." || relativePath.startsWith(`..${path26.sep}`) || path26.isAbsolute(relativePath);
+    return relativePath === ".." || relativePath.startsWith(`..${path28.sep}`) || path28.isAbsolute(relativePath);
   }
   getNearestExistingDirectory(directoryPath) {
     let candidate = directoryPath;
     while (!(0, import_fs19.existsSync)(candidate)) {
-      const parent = path26.dirname(candidate);
+      const parent = path28.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -20122,9 +21267,51 @@ var FileWatcher = class {
   }
   getProjectConfigRelativePaths() {
     return this.projectConfigPaths.map(
-      (configPath) => path26.normalize(path26.relative(this.projectRoot, configPath))
+      (configPath) => path28.normalize(path28.relative(this.projectRoot, configPath))
     );
   }
+  getConfigPathStates() {
+    const states = /* @__PURE__ */ new Map();
+    for (const configPath of this.projectConfigPaths) {
+      const state = this.getConfigPathState(configPath);
+      if (state) states.set(configPath, state);
+    }
+    return states;
+  }
+  getConfigPathState(configPath) {
+    try {
+      const stats = (0, import_fs19.statSync)(configPath);
+      return stats.isFile() ? { mtimeMs: stats.mtimeMs, size: stats.size } : void 0;
+    } catch (error) {
+      void error;
+      return void 0;
+    }
+  }
+  updateConfigPathState(configPath) {
+    const state = this.getConfigPathState(configPath);
+    if (state) {
+      this.configPathStates.set(configPath, state);
+    } else {
+      this.configPathStates.delete(configPath);
+    }
+  }
+  reconcileConfigPathStates() {
+    const nextStates = this.getConfigPathStates();
+    const changes = [];
+    for (const configPath of this.projectConfigPaths) {
+      const previous = this.configPathStates.get(configPath);
+      const next = nextStates.get(configPath);
+      if (!previous && next) {
+        changes.push({ path: configPath, type: "add" });
+      } else if (previous && !next) {
+        changes.push({ path: configPath, type: "unlink" });
+      } else if (previous && next && (previous.size !== next.size || previous.mtimeMs !== next.mtimeMs)) {
+        changes.push({ path: configPath, type: "change" });
+      }
+    }
+    this.configPathStates = nextStates;
+    this.recordChanges(changes);
+  }
   scheduleFlush() {
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
@@ -20138,7 +21325,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path31, type]) => ({ path: path31, type })
+      ([path33, type]) => ({ path: path33, type })
     );
     this.pendingChanges.clear();
     try {
@@ -20152,20 +21339,31 @@ var FileWatcher = class {
       clearTimeout(this.debounceTimer);
       this.debounceTimer = null;
     }
+    if (this.nativeReconcileTimer) {
+      clearTimeout(this.nativeReconcileTimer);
+      this.nativeReconcileTimer = null;
+    }
+    this.nativeInvalidatedPaths.clear();
     const watcher = this.watcher;
+    const nativeWatcher = this.nativeWatcher;
     const pendingClose = this.pendingClose;
     const resolveReady = this.resolveReady;
     this.watcher = null;
+    this.nativeWatcher = null;
+    this.nativeReconciler = null;
+    this.nativeStarting = false;
+    this.nativeInitializing = false;
+    this.nativeSetupGeneration += 1;
     this.pendingClose = null;
     this.resolveReady = null;
     this.readyPromise = null;
     this.pendingChanges.clear();
     this.onChanges = null;
-    await Promise.all([watcher?.close(), pendingClose]);
+    await Promise.all([watcher?.close(), nativeWatcher?.stop(), pendingClose]);
     resolveReady?.();
   }
   isRunning() {
-    return this.watcher !== null;
+    return this.watcher !== null || this.nativeWatcher !== null || this.nativeStarting;
   }
   async waitUntilReady() {
     await (this.readyPromise ?? Promise.resolve());
@@ -20173,7 +21371,7 @@ var FileWatcher = class {
 };
 
 // src/watcher/git-head-watcher.ts
-var path27 = __toESM(require("path"), 1);
+var path29 = __toESM(require("path"), 1);
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -20195,13 +21393,13 @@ var GitHeadWatcher = class {
       this.readyPromise = Promise.resolve();
       return;
     }
-    this.readyPromise = new Promise((resolve18) => {
-      this.resolveReady = resolve18;
+    this.readyPromise = new Promise((resolve20) => {
+      this.resolveReady = resolve20;
     });
     this.onBranchChange = handler;
     this.currentBranch = getCurrentBranch(this.projectRoot);
     const headPath = getHeadPath(this.projectRoot);
-    const refsPath = path27.join(this.projectRoot, ".git", "refs", "heads");
+    const refsPath = path29.join(this.projectRoot, ".git", "refs", "heads");
     this.watcher = chokidar_default.watch([headPath, refsPath], {
       persistent: true,
       ignoreInitial: true,
@@ -20337,7 +21535,7 @@ function getConfigPaths(projectRoot, host, options) {
 
 // src/tools/visualize/activity.ts
 var import_child_process5 = require("child_process");
-var path28 = __toESM(require("path"), 1);
+var path30 = __toESM(require("path"), 1);
 function attachRecentActivity(data, projectRoot) {
   const activity = readGitActivity(projectRoot);
   const changes = activity.size > 0 ? buildGitChanges(data, activity, projectRoot) : buildGraphChanges(data);
@@ -20499,7 +21697,7 @@ function normalizePath4(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function toGitRelativePath(projectRoot, filePath) {
-  const relativePath = path28.isAbsolute(filePath) ? path28.relative(projectRoot, filePath) : filePath;
+  const relativePath = path30.isAbsolute(filePath) ? path30.relative(projectRoot, filePath) : filePath;
   return normalizePath4(relativePath);
 }
 
@@ -20757,7 +21955,7 @@ render();
 }
 
 // src/tools/visualize/transform.ts
-var path29 = __toESM(require("path"), 1);
+var path31 = __toESM(require("path"), 1);
 
 // src/tools/visualize/modules.ts
 var MAX_MODULES = 18;
@@ -20890,8 +22088,8 @@ function compactModules(prefixToNodes) {
 function deriveModules(nodes) {
   const initial = /* @__PURE__ */ new Map();
   for (const node of nodes) {
-    const relative12 = stripToProjectRelative(node.filePath);
-    const prefix = modulePrefixFromRelativePath(relative12);
+    const relative14 = stripToProjectRelative(node.filePath);
+    const prefix = modulePrefixFromRelativePath(relative14);
     if (!initial.has(prefix)) initial.set(prefix, []);
     initial.get(prefix)?.push(node);
   }
@@ -21017,7 +22215,7 @@ function transformForVisualization(symbols, edges, options = {}) {
     filePath: s.filePath,
     kind: s.kind,
     line: s.startLine,
-    directory: path29.dirname(s.filePath),
+    directory: path31.dirname(s.filePath),
     moduleId: "",
     moduleLabel: ""
   }));
@@ -21045,9 +22243,9 @@ function parseArgs(argv) {
   let host = "opencode";
   for (let i = 2; i < argv.length; i++) {
     if (argv[i] === "--project" && argv[i + 1]) {
-      project = path30.resolve(argv[++i]);
+      project = path32.resolve(argv[++i]);
     } else if (argv[i] === "--config" && argv[i + 1]) {
-      config = path30.resolve(argv[++i]);
+      config = path32.resolve(argv[++i]);
     } else if (argv[i] === "--host" && argv[i + 1]) {
       host = parseHostMode(argv[++i]);
     } else if (argv[i] === "--host") {
@@ -21074,7 +22272,7 @@ function parseIndexArgs(argv, cwd) {
       if (!arg.startsWith("--project=")) {
         i += 1;
       }
-      project = path30.resolve(cwd, value);
+      project = path32.resolve(cwd, value);
       continue;
     }
     if (arg === "--config" || arg.startsWith("--config=")) {
@@ -21085,7 +22283,7 @@ function parseIndexArgs(argv, cwd) {
       if (!arg.startsWith("--config=")) {
         i += 1;
       }
-      config = path30.resolve(cwd, value);
+      config = path32.resolve(cwd, value);
       continue;
     }
     if (arg === "--host" || arg.startsWith("--host=")) {
@@ -21151,7 +22349,7 @@ function parseVisualizeArgs(argv, cwd) {
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--project" && argv[i + 1]) {
-      project = path30.resolve(argv[++i]);
+      project = path32.resolve(argv[++i]);
     } else if (arg === "--max" && argv[i + 1]) {
       maxNodes = Number(argv[++i]);
     } else if (arg.startsWith("--max=") || arg.startsWith("max=")) {
@@ -21188,7 +22386,7 @@ async function handleVisualizeCommand(argv, cwd) {
       console.error("No connected symbols found. Retry with: npm run visualize -- orphans");
       return 1;
     }
-    const outputPath = path30.join(os8.tmpdir(), `call-graph-${Date.now()}.html`);
+    const outputPath = path32.join(os8.tmpdir(), `call-graph-${Date.now()}.html`);
     (0, import_fs20.writeFileSync)(outputPath, generateVisualizationHtml(vizData), "utf-8");
     console.log(`Temporal call graph visualization generated: ${outputPath}`);
     console.log(`Nodes: ${vizData.nodes.length} | Edges: ${vizData.edges.length}`);
@@ -21220,8 +22418,60 @@ async function runMcpCli(argv) {
   const config = parseConfig(rawConfig);
   const server = createMcpServer(args.project, config, args.host);
   const transport = new import_stdio.StdioServerTransport();
-  await server.connect(transport);
   let watcher = null;
+  let shutdownPromise;
+  const onServerClose = server.server.onclose;
+  const shutdown = () => {
+    if (shutdownPromise) return shutdownPromise;
+    process.stdin.removeListener("end", requestShutdown);
+    process.stdin.removeListener("close", requestShutdown);
+    process.removeListener("SIGHUP", requestShutdown);
+    process.removeListener("SIGINT", requestShutdown);
+    process.removeListener("SIGTERM", requestShutdown);
+    server.server.onclose = onServerClose;
+    shutdownPromise = (async () => {
+      let exitCode = 0;
+      try {
+        await watcher?.stop();
+      } catch (error) {
+        exitCode = 1;
+        console.error("Failed to stop MCP file watcher cleanly:", error);
+      }
+      try {
+        await stopAutoIndex(args.project, args.host);
+      } catch (error) {
+        exitCode = 1;
+        console.error("Failed to stop automatic indexing cleanly:", error);
+      }
+      try {
+        await server.close();
+      } catch (error) {
+        exitCode = 1;
+        console.error("Failed to close MCP server cleanly:", error);
+      }
+      process.exit(exitCode);
+    })();
+    return shutdownPromise;
+  };
+  const requestShutdown = () => {
+    void shutdown();
+  };
+  server.server.onclose = () => {
+    try {
+      onServerClose?.();
+    } finally {
+      requestShutdown();
+    }
+  };
+  process.stdin.once("end", requestShutdown);
+  process.stdin.once("close", requestShutdown);
+  process.once("SIGINT", requestShutdown);
+  if (process.platform !== "win32") {
+    process.once("SIGHUP", requestShutdown);
+    process.once("SIGTERM", requestShutdown);
+  }
+  await server.connect(transport);
+  if (shutdownPromise) return;
   const isHomeDir = isHomeDirectory(args.project);
   const isValidProject = !isHomeDir && (!config.indexing.requireProjectMarker || hasProjectMarker(args.project));
   if (config.indexing.watchFiles && isValidProject) {
@@ -21233,26 +22483,6 @@ async function runMcpCli(argv) {
       args.config ? { configPath: args.config } : {}
     );
   }
-  let shuttingDown = false;
-  const shutdown = async () => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    try {
-      await watcher?.stop();
-      await stopAutoIndex(args.project, args.host);
-      await server.close();
-      process.exit(0);
-    } catch (error) {
-      console.error("Failed to stop MCP server cleanly:", error);
-      process.exit(1);
-    }
-  };
-  process.on("SIGINT", () => {
-    void shutdown();
-  });
-  process.on("SIGTERM", () => {
-    void shutdown();
-  });
 }
 function printIndexProgress(onProgress, title, metadata) {
   const details = Object.entries(metadata).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${isSensitiveKey(key) ? "[REDACTED]" : String(value)}`).join(" ");