opencode-codebase-index 0.16.0 → 0.17.0

package/dist/pi-extension.cjs

@@ -655,6 +655,467 @@ var require_ignore = __commonJS({
   }
 });
 
+// node_modules/tiktoken/tiktoken_bg.cjs
+var require_tiktoken_bg = __commonJS({
+  "node_modules/tiktoken/tiktoken_bg.cjs"(exports2, module3) {
+    "use strict";
+    var wasm;
+    module3.exports.__wbg_set_wasm = function(val) {
+      wasm = val;
+    };
+    var lTextDecoder = typeof TextDecoder === "undefined" ? (0, module3.require)("util").TextDecoder : TextDecoder;
+    var cachedTextDecoder = new lTextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    var cachedUint8ArrayMemory0 = null;
+    function getUint8ArrayMemory0() {
+      if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+      }
+      return cachedUint8ArrayMemory0;
+    }
+    function getStringFromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+    }
+    var heap = new Array(128).fill(void 0);
+    heap.push(void 0, null, true, false);
+    var heap_next = heap.length;
+    function addHeapObject(obj) {
+      if (heap_next === heap.length) heap.push(heap.length + 1);
+      const idx = heap_next;
+      heap_next = heap[idx];
+      heap[idx] = obj;
+      return idx;
+    }
+    function handleError(f, args) {
+      try {
+        return f.apply(this, args);
+      } catch (e) {
+        wasm.__wbindgen_export_0(addHeapObject(e));
+      }
+    }
+    function getObject(idx) {
+      return heap[idx];
+    }
+    function dropObject(idx) {
+      if (idx < 132) return;
+      heap[idx] = heap_next;
+      heap_next = idx;
+    }
+    function takeObject(idx) {
+      const ret = getObject(idx);
+      dropObject(idx);
+      return ret;
+    }
+    var WASM_VECTOR_LEN = 0;
+    var lTextEncoder = typeof TextEncoder === "undefined" ? (0, module3.require)("util").TextEncoder : TextEncoder;
+    var cachedTextEncoder = new lTextEncoder("utf-8");
+    var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+      return cachedTextEncoder.encodeInto(arg, view);
+    } : function(arg, view) {
+      const buf = cachedTextEncoder.encode(arg);
+      view.set(buf);
+      return {
+        read: arg.length,
+        written: buf.length
+      };
+    };
+    function passStringToWasm0(arg, malloc, realloc) {
+      if (realloc === void 0) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr2 = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr2;
+      }
+      let len = arg.length;
+      let ptr = malloc(len, 1) >>> 0;
+      const mem = getUint8ArrayMemory0();
+      let offset = 0;
+      for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 127) break;
+        mem[ptr + offset] = code;
+      }
+      if (offset !== len) {
+        if (offset !== 0) {
+          arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+      }
+      WASM_VECTOR_LEN = offset;
+      return ptr;
+    }
+    function isLikeNone(x) {
+      return x === void 0 || x === null;
+    }
+    var cachedDataViewMemory0 = null;
+    function getDataViewMemory0() {
+      if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+      }
+      return cachedDataViewMemory0;
+    }
+    var cachedUint32ArrayMemory0 = null;
+    function getUint32ArrayMemory0() {
+      if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+      }
+      return cachedUint32ArrayMemory0;
+    }
+    function getArrayU32FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+    }
+    function passArray8ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 1, 1) >>> 0;
+      getUint8ArrayMemory0().set(arg, ptr / 1);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+    }
+    function passArray32ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 4, 4) >>> 0;
+      getUint32ArrayMemory0().set(arg, ptr / 4);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+    }
+    function getArrayU8FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+    }
+    module3.exports.get_encoding = function(encoding, extend_special_tokens) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(encoding, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.get_encoding(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+          throw takeObject(r1);
+        }
+        return Tiktoken.__wrap(r0);
+      } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+      }
+    };
+    module3.exports.encoding_for_model = function(model, extend_special_tokens) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(model, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.encoding_for_model(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+          throw takeObject(r1);
+        }
+        return Tiktoken.__wrap(r0);
+      } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+      }
+    };
+    module3.exports.get_encoding_name_for_model = function(model) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      let deferred3_0;
+      let deferred3_1;
+      try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(model, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.get_encoding_name_for_model(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+          ptr2 = 0;
+          len2 = 0;
+          throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+      } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_3(deferred3_0, deferred3_1, 1);
+      }
+    };
+    var TiktokenFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_tiktoken_free(ptr >>> 0, 1));
+    var Tiktoken = class _Tiktoken {
+      /**
+       * @param {string} tiktoken_bfe
+       * @param {any} special_tokens
+       * @param {string} pat_str
+       */
+      constructor(tiktoken_bfe, special_tokens, pat_str) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr0 = passStringToWasm0(tiktoken_bfe, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(pat_str, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.tiktoken_new(ptr0, len0, addHeapObject(special_tokens), ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        TiktokenFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /** @returns {string | undefined} */
+      get name() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.tiktoken_name(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          let v1;
+          if (r0 !== 0) {
+            v1 = getStringFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+          }
+          return v1;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_Tiktoken.prototype);
+        obj.__wbg_ptr = ptr;
+        TiktokenFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TiktokenFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tiktoken_free(ptr, 0);
+      }
+      /**
+       * @param {string} text
+       * @param {any} allowed_special
+       * @param {any} disallowed_special
+       * @returns {Uint32Array}
+       */
+      encode(text3, allowed_special, disallowed_special) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text3, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_encode(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+          if (r3) {
+            throw takeObject(r2);
+          }
+          var v2 = getArrayU32FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 4, 4);
+          return v2;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {string} text
+       * @returns {Uint32Array}
+       */
+      encode_ordinary(text3) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text3, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_encode_ordinary(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v2 = getArrayU32FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 4, 4);
+          return v2;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {string} text
+       * @param {any} allowed_special
+       * @param {any} disallowed_special
+       * @returns {any}
+       */
+      encode_with_unstable(text3, allowed_special, disallowed_special) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text3, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_encode_with_unstable(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {Uint8Array} bytes
+       * @returns {number}
+       */
+      encode_single_token(bytes) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tiktoken_encode_single_token(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+      }
+      /**
+       * @param {Uint32Array} tokens
+       * @returns {Uint8Array}
+       */
+      decode(tokens) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passArray32ToWasm0(tokens, wasm.__wbindgen_export_1);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_decode(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v2 = getArrayU8FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+          return v2;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {number} token
+       * @returns {Uint8Array}
+       */
+      decode_single_token_bytes(token) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.tiktoken_decode_single_token_bytes(retptr, this.__wbg_ptr, token);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v1 = getArrayU8FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+          return v1;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /** @returns {any} */
+      token_byte_values() {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ret = wasm.tiktoken_token_byte_values(this.__wbg_ptr);
+        return takeObject(ret);
+      }
+    };
+    module3.exports.Tiktoken = Tiktoken;
+    module3.exports.__wbg_parse_def2e24ef1252aff = function() {
+      return handleError(function(arg0, arg1) {
+        const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+      }, arguments);
+    };
+    module3.exports.__wbg_stringify_f7ed6987935b4a24 = function() {
+      return handleError(function(arg0) {
+        const ret = JSON.stringify(getObject(arg0));
+        return addHeapObject(ret);
+      }, arguments);
+    };
+    module3.exports.__wbindgen_error_new = function(arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return addHeapObject(ret);
+    };
+    module3.exports.__wbindgen_is_undefined = function(arg0) {
+      const ret = getObject(arg0) === void 0;
+      return ret;
+    };
+    module3.exports.__wbindgen_object_drop_ref = function(arg0) {
+      takeObject(arg0);
+    };
+    module3.exports.__wbindgen_string_get = function(arg0, arg1) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      const obj = getObject(arg1);
+      const ret = typeof obj === "string" ? obj : void 0;
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    module3.exports.__wbindgen_throw = function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+  }
+});
+
+// node_modules/tiktoken/tiktoken.cjs
+var require_tiktoken = __commonJS({
+  "node_modules/tiktoken/tiktoken.cjs"(exports2) {
+    "use strict";
+    var wasm = require_tiktoken_bg();
+    var imports = {};
+    imports["./tiktoken_bg.js"] = wasm;
+    var path17 = require("path");
+    var fs = require("fs");
+    var candidates = __dirname.split(path17.sep).reduce((memo, _, index, array) => {
+      const prefix = array.slice(0, index + 1).join(path17.sep) + path17.sep;
+      if (!prefix.includes("node_modules" + path17.sep)) {
+        memo.unshift(
+          path17.join(
+            prefix,
+            "node_modules",
+            "tiktoken",
+            "",
+            "./tiktoken_bg.wasm"
+          )
+        );
+      }
+      return memo;
+    }, []);
+    candidates.unshift(path17.join(__dirname, "./tiktoken_bg.wasm"));
+    var bytes = null;
+    for (const candidate of candidates) {
+      try {
+        bytes = fs.readFileSync(candidate);
+        break;
+      } catch {
+      }
+    }
+    if (bytes == null) throw new Error("Missing tiktoken_bg.wasm");
+    var wasmModule = new WebAssembly.Module(bytes);
+    var wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+    wasm.__wbg_set_wasm(wasmInstance.exports);
+    exports2["get_encoding"] = wasm["get_encoding"];
+    exports2["encoding_for_model"] = wasm["encoding_for_model"];
+    exports2["get_encoding_name_for_model"] = wasm["get_encoding_name_for_model"];
+    exports2["Tiktoken"] = wasm["Tiktoken"];
+  }
+});
+
 // src/pi-extension.ts
 var pi_extension_exports = {};
 __export(pi_extension_exports, {
@@ -4955,7 +5416,12 @@ function sameReclaimOwner(left, right) {
 }
 function publishJsonDirectory(finalPath, value) {
   const candidatePath = `${finalPath}.candidate.${process.pid}.${(0, import_crypto.randomUUID)()}`;
-  (0, import_fs7.mkdirSync)(candidatePath, { mode: 448 });
+  try {
+    (0, import_fs7.mkdirSync)(candidatePath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
+  }
   try {
     (0, import_fs7.writeFileSync)(path12.join(candidatePath, OWNER_FILE_NAME), JSON.stringify(value), {
       encoding: "utf-8",
@@ -4968,8 +5434,12 @@ function publishJsonDirectory(finalPath, value) {
       return true;
     } catch (error) {
       if ((0, import_fs7.existsSync)(finalPath)) return false;
+      if (getErrorCode(error) === "ENOENT") return false;
       throw error;
     }
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
   } finally {
     if ((0, import_fs7.existsSync)(candidatePath)) (0, import_fs7.rmSync)(candidatePath, { recursive: true, force: true });
   }
@@ -6538,6 +7008,27 @@ function mergeTieredResults(symbolLane, hybridLane, limit) {
   }
   return out;
 }
+function selectChunksWithFileCoverage(chunks, limit) {
+  if (limit <= 0 || chunks.length === 0) {
+    return [];
+  }
+  if (chunks.length <= limit) {
+    return chunks;
+  }
+  if (limit === 1) {
+    return [chunks[Math.floor((chunks.length - 1) / 2)]];
+  }
+  const selected = [];
+  for (let index = 0; index < limit; index++) {
+    const sourceIndex = Math.round(index * (chunks.length - 1) / (limit - 1));
+    selected.push(chunks[sourceIndex]);
+  }
+  return selected;
+}
+function selectIndexableChunks(chunks, limit, semanticOnly) {
+  const indexableChunks = semanticOnly ? chunks.filter((chunk) => chunk.chunkType !== "other") : chunks;
+  return selectChunksWithFileCoverage(indexableChunks, limit);
+}
 function matchesSearchFilters(candidate, options, minScore) {
   if (candidate.score < minScore) return false;
   if (options?.fileType) {
@@ -8276,7 +8767,6 @@ var Indexer = class {
         const relativePath = path13.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
-      let fileChunkCount = 0;
       let chunksToProcess = parsed.chunks;
       if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
         const changedFile = changedFiles.find((f) => f.path === parsed.path);
@@ -8285,13 +8775,12 @@ var Indexer = class {
           chunksToProcess = textChunks;
         }
       }
+      chunksToProcess = selectIndexableChunks(
+        chunksToProcess,
+        this.config.indexing.maxChunksPerFile,
+        this.config.indexing.semanticOnly
+      );
       for (const chunk of chunksToProcess) {
-        if (fileChunkCount >= this.config.indexing.maxChunksPerFile) {
-          break;
-        }
-        if (this.config.indexing.semanticOnly && chunk.chunkType === "other") {
-          continue;
-        }
         const id = generateChunkId(parsed.path, chunk);
         const contentHash = generateChunkHash(chunk);
         const existingContentHash = existingChunks.get(id);
@@ -8315,7 +8804,6 @@ var Indexer = class {
           blameSummary: blameMetadata.blameSummary
         });
         if (existingContentHash === contentHash) {
-          fileChunkCount++;
           continue;
         }
         const texts = createEmbeddingTexts(chunk, parsed.path, getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)).map((text3) => ({
@@ -8340,7 +8828,6 @@ var Indexer = class {
           contentHash,
           metadata
         });
-        fileChunkCount++;
       }
     }
     const retryableFailedChunks = this.collectRetryableFailedChunks(
@@ -9931,6 +10418,159 @@ function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot3) {
 }
 
 // src/tools/utils.ts
+var import_tiktoken = __toESM(require_tiktoken(), 1);
+var MIN_CONTEXT_PACK_TOKEN_BUDGET = 128;
+var MAX_CONTEXT_PACK_TOKEN_BUDGET = 4e3;
+var DEFAULT_CONTEXT_PACK_TOKEN_BUDGET = 1200;
+var CONTEXT_TOKENIZER = (0, import_tiktoken.get_encoding)("cl100k_base");
+function clampContextPackTokenBudget(tokenBudget) {
+  if (tokenBudget === void 0 || !Number.isFinite(tokenBudget)) {
+    return DEFAULT_CONTEXT_PACK_TOKEN_BUDGET;
+  }
+  return Math.min(
+    MAX_CONTEXT_PACK_TOKEN_BUDGET,
+    Math.max(MIN_CONTEXT_PACK_TOKEN_BUDGET, Math.floor(tokenBudget))
+  );
+}
+function countContextTokens(text3) {
+  return CONTEXT_TOKENIZER.encode(text3).length;
+}
+function fitTextToContextBudget(text3, tokenBudget) {
+  const normalizedBudget = clampContextPackTokenBudget(tokenBudget);
+  const tokenEstimate = countContextTokens(text3);
+  if (tokenEstimate <= normalizedBudget) {
+    return {
+      text: text3,
+      tokenBudget: normalizedBudget,
+      tokenEstimate,
+      truncated: false
+    };
+  }
+  const suffix = "\n...[truncated to context token budget]";
+  const codePoints = Array.from(text3);
+  let low = 0;
+  let high = codePoints.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    const candidate = `${codePoints.slice(0, middle).join("").trimEnd()}${suffix}`;
+    if (countContextTokens(candidate) <= normalizedBudget) low = middle;
+    else high = middle - 1;
+  }
+  const fitted = `${codePoints.slice(0, low).join("").trimEnd()}${suffix}`;
+  return {
+    text: fitted,
+    tokenBudget: normalizedBudget,
+    tokenEstimate: countContextTokens(fitted),
+    truncated: true
+  };
+}
+function normalizedLineRange(result) {
+  return result.startLine <= result.endLine ? { start: result.startLine, end: result.endLine } : { start: result.endLine, end: result.startLine };
+}
+function rankContextCandidates(results) {
+  return results.map((result, originalIndex) => ({ result, originalIndex })).sort((left, right) => right.result.score - left.result.score || left.originalIndex - right.originalIndex);
+}
+function deduplicateContextCandidates(candidates) {
+  const acceptedByFile = /* @__PURE__ */ new Map();
+  const deduplicated = [];
+  for (const { result } of candidates) {
+    const range = normalizedLineRange(result);
+    const accepted = acceptedByFile.get(result.filePath) ?? [];
+    if (accepted.some((item) => item.start <= range.end && range.start <= item.end)) {
+      continue;
+    }
+    accepted.push(range);
+    acceptedByFile.set(result.filePath, accepted);
+    deduplicated.push(result);
+  }
+  return deduplicated;
+}
+function diversifyContextCandidates(results) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const bucket = byFile.get(result.filePath) ?? [];
+    bucket.push(result);
+    byFile.set(result.filePath, bucket);
+  }
+  const files = [...byFile.keys()];
+  const diversified = [];
+  for (let depth = 0; diversified.length < results.length; depth += 1) {
+    for (const file of files) {
+      const result = byFile.get(file)?.[depth];
+      if (result) diversified.push(result);
+    }
+  }
+  return diversified;
+}
+function compactEvidenceValue(value, maxChars) {
+  const characters = [...value];
+  if (characters.length <= maxChars) return value;
+  return `\u2026${characters.slice(-(maxChars - 1)).join("")}`;
+}
+function formatContextEvidence(result, index) {
+  const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
+  const path17 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path17}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+}
+function formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, budgetOmittedCount) {
+  const lines = selected.map((result, index) => formatContextEvidence(result, index + 1));
+  const notes = [];
+  if (duplicateCount > 0) notes.push(`${duplicateCount} overlapping duplicate${duplicateCount === 1 ? "" : "s"} removed`);
+  if (limitOmittedCount > 0) notes.push(`${limitOmittedCount} additional result${limitOmittedCount === 1 ? "" : "s"} excluded by result limit`);
+  if (budgetOmittedCount > 0) notes.push(`${budgetOmittedCount} additional result${budgetOmittedCount === 1 ? "" : "s"} omitted by token budget`);
+  const footer = notes.length > 0 ? `Selected ${selected.length} of ${candidateCount} candidates; ${notes.join("; ")}.` : `Selected ${selected.length} of ${candidateCount} candidates.`;
+  return `${heading}
+
+${lines.join("\n")}
+
+${footer}`;
+}
+function buildContextPack(results, options = {}) {
+  const requestedTokenBudget = options.tokenBudget ?? DEFAULT_CONTEXT_PACK_TOKEN_BUDGET;
+  const tokenBudget = clampContextPackTokenBudget(options.tokenBudget);
+  const heading = compactEvidenceValue(options.heading?.trim() || "Codebase evidence", 160);
+  const maxResults = Math.max(0, Math.floor(options.maxResults ?? results.length));
+  const candidateCount = results.length;
+  const deduplicated = deduplicateContextCandidates(rankContextCandidates(results));
+  const diversified = diversifyContextCandidates(deduplicated);
+  const duplicateCount = candidateCount - deduplicated.length;
+  const selectable = diversified.slice(0, maxResults);
+  const limitOmittedCount = deduplicated.length - selectable.length;
+  let selected = [];
+  let text3 = formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, selectable.length);
+  for (let count = 1; count <= selectable.length; count += 1) {
+    const candidateSelection = selectable.slice(0, count);
+    const budgetOmittedCount2 = selectable.length - candidateSelection.length;
+    const candidateText = formatContextPack(
+      heading,
+      candidateSelection,
+      candidateCount,
+      duplicateCount,
+      limitOmittedCount,
+      budgetOmittedCount2
+    );
+    if (countContextTokens(candidateText) > tokenBudget) break;
+    selected = candidateSelection;
+    text3 = candidateText;
+  }
+  const fitted = fitTextToContextBudget(text3, tokenBudget);
+  const budgetOmittedCount = selectable.length - selected.length;
+  const omittedCount = candidateCount - selected.length;
+  return {
+    requestedTokenBudget,
+    tokenBudget,
+    text: fitted.text,
+    tokenEstimate: fitted.tokenEstimate,
+    results: selected,
+    candidateCount,
+    deduplicatedCount: deduplicated.length,
+    selectedCount: selected.length,
+    omittedCount,
+    duplicateCount,
+    limitOmittedCount,
+    budgetOmittedCount
+  };
+}
 var MAX_CONTENT_LINES = 30;
 function truncateContent(content) {
   const lines = content.split("\n");
@@ -10075,17 +10715,6 @@ function calculatePercentage(progress) {
   if (progress.phase === "storing") return 95;
   return 0;
 }
-function formatCodebasePeek(results) {
-  if (results.length === 0) {
-    return "No matching code found. Try a different query or run index_codebase first.";
-  }
-  const formatted = results.map((r, idx) => {
-    const location = `${r.filePath}:${r.startLine}-${r.endLine}`;
-    const name = r.name ? `"${r.name}"` : "(anonymous)";
-    return `[${idx + 1}] ${r.chunkType} ${name} at ${location} (score: ${r.score.toFixed(2)})${formatBlame(r)}`;
-  });
-  return formatted.join("\n");
-}
 function formatHealthCheck(result) {
   if (result.resetCorruptedIndex) {
     return result.warning ?? "Detected a corrupted local index and reset it. Run index_codebase to rebuild search data.";
@@ -10599,6 +11228,253 @@ Run /index to rebuild the index without the removed knowledge base.`;
   return result;
 }
 
+// src/tools/symbol-inference.ts
+var IDENTIFIER_RE = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+var QUOTED_BACKTICK_RE = /`([^`]+)`/g;
+var QUOTED_SINGLE_RE = /'([^'\\]+)'/g;
+var QUOTED_DOUBLE_RE = /"([^"]+)"/g;
+var SYMBOL_LIKE_RE = /^(?:[A-Za-z_$][A-Za-z0-9_$]*)$/;
+var CAMEL_CASE_RE = /^[a-z_][A-Za-z0-9_$]*[A-Z][A-Za-z0-9_$]*$/;
+var PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9_$]*$/;
+var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*_[a-z0-9_]+$/;
+var DEFINITION_INTENT_RE = /\b(where|defined|definition|define|declaration|symbol|function|method|class|interface|type)\b/i;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "at",
+  "for",
+  "find",
+  "how",
+  "i",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "that",
+  "the",
+  "definition",
+  "show",
+  "to",
+  "where",
+  "which",
+  "what",
+  "you",
+  "your",
+  "with"
+]);
+function stripCallSuffix(token) {
+  return token.replace(/\(\s*\)$/, "");
+}
+function isLikelySymbolName(token) {
+  if (!SYMBOL_LIKE_RE.test(token)) {
+    return false;
+  }
+  if (STOP_WORDS.has(token.toLowerCase())) {
+    return false;
+  }
+  return CAMEL_CASE_RE.test(token) || PASCAL_CASE_RE.test(token) || SNAKE_CASE_RE.test(token);
+}
+function extractQuotedIdentifiers(query) {
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const match of query.matchAll(QUOTED_BACKTICK_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  for (const match of query.matchAll(QUOTED_SINGLE_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  for (const match of query.matchAll(QUOTED_DOUBLE_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  return [...identifiers];
+}
+function extractBareIdentifiers(query) {
+  const unquoted = query.replace(QUOTED_BACKTICK_RE, " ").replace(QUOTED_SINGLE_RE, " ").replace(QUOTED_DOUBLE_RE, " ");
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const match of unquoted.matchAll(IDENTIFIER_RE)) {
+    const candidate = stripCallSuffix(match[0]);
+    if (isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  return [...identifiers];
+}
+function isSingleMeaningfulToken(query, symbol) {
+  const tokens = query.replace(/[`'"()]/g, " ").split(/[^A-Za-z0-9_$]+/).map((token) => token.trim().toLowerCase()).filter((token) => token.length > 0).filter((token) => !STOP_WORDS.has(token));
+  return tokens.length === 1 && tokens[0] === symbol.toLowerCase();
+}
+function inferExactSymbolFromQuery(query) {
+  const quoted = extractQuotedIdentifiers(query);
+  if (quoted.length === 1) {
+    return quoted[0];
+  }
+  if (quoted.length > 1) {
+    return void 0;
+  }
+  const candidates = extractBareIdentifiers(query);
+  if (candidates.length !== 1) {
+    return void 0;
+  }
+  const candidate = candidates[0];
+  if (DEFINITION_INTENT_RE.test(query)) {
+    return candidate;
+  }
+  if (isSingleMeaningfulToken(query, candidate)) {
+    return candidate;
+  }
+  return void 0;
+}
+
+// src/tools/context.ts
+var MIN_CONTEXT_RESULT_LIMIT = 1;
+var MAX_CONTEXT_RESULT_LIMIT = 100;
+var MIN_CONTEXT_PATH_DEPTH = 1;
+var MAX_CONTEXT_PATH_DEPTH = 100;
+function locations(results) {
+  return results.map((result) => ({
+    filePath: result.filePath,
+    startLine: result.startLine,
+    endLine: result.endLine,
+    score: result.score,
+    chunkType: result.chunkType,
+    name: result.name
+  }));
+}
+function packedResult(route, routedQuery, pack) {
+  return {
+    text: pack.text,
+    details: {
+      route,
+      routedQuery,
+      tokenBudget: pack.tokenBudget,
+      tokenEstimate: pack.tokenEstimate,
+      candidateCount: pack.candidateCount,
+      deduplicatedCount: pack.deduplicatedCount,
+      selectedCount: pack.selectedCount,
+      omittedCount: pack.omittedCount,
+      duplicateCount: pack.duplicateCount,
+      limitOmittedCount: pack.limitOmittedCount,
+      budgetOmittedCount: pack.budgetOmittedCount,
+      results: locations(pack.results)
+    }
+  };
+}
+async function resolveSearchContext(input, operations) {
+  const explicitSymbol = input.symbol ?? void 0;
+  const limit = input.limit ?? 10;
+  const tokenBudget = input.tokenBudget ?? void 0;
+  const lookupSymbol = explicitSymbol ?? inferExactSymbolFromQuery(input.query);
+  if (lookupSymbol) {
+    const definitions = await operations.lookup(lookupSymbol, MAX_CONTEXT_RESULT_LIMIT);
+    if (definitions.length > 0) {
+      return packedResult("definition", lookupSymbol, buildContextPack(definitions, {
+        tokenBudget,
+        maxResults: limit,
+        heading: `Definition evidence for ${JSON.stringify(lookupSymbol)}`
+      }));
+    }
+    if (explicitSymbol) {
+      const fitted = fitTextToContextBudget(
+        formatDefinitionLookup(definitions, lookupSymbol),
+        tokenBudget
+      );
+      return { text: fitted.text };
+    }
+  }
+  const results = await operations.search(input.query, MAX_CONTEXT_RESULT_LIMIT);
+  if (results.length === 0) {
+    const fitted = fitTextToContextBudget(
+      "No matching code found. Try a different query or run index_codebase first.",
+      tokenBudget
+    );
+    return { text: fitted.text };
+  }
+  return packedResult("conceptual", input.query, buildContextPack(results, {
+    tokenBudget,
+    maxResults: limit,
+    heading: `Codebase evidence for ${JSON.stringify(input.query)}`
+  }));
+}
+function fittedDetails(route, fitted) {
+  return {
+    route,
+    tokenBudget: fitted.tokenBudget,
+    tokenEstimate: fitted.tokenEstimate,
+    truncated: fitted.truncated
+  };
+}
+async function resolveCodebaseContext(projectRoot3, host, input) {
+  const from = input.from ?? void 0;
+  const to = input.to ?? void 0;
+  const symbol = input.symbol ?? void 0;
+  const limit = input.limit ?? 10;
+  const maxDepth = input.maxDepth ?? 10;
+  const fileType = input.fileType ?? void 0;
+  const directory = input.directory ?? void 0;
+  const tokenBudget = input.tokenBudget ?? void 0;
+  if (from && to) {
+    const path17 = await getCallGraphPath(projectRoot3, host, from, to, maxDepth);
+    if (path17.length > 0) {
+      const fitted2 = fitTextToContextBudget(
+        formatCallGraphPath(from, to, path17),
+        tokenBudget
+      );
+      return {
+        text: fitted2.text,
+        details: fittedDetails("path", fitted2)
+      };
+    }
+    const { callers } = await getCallGraphData(projectRoot3, host, {
+      name: to,
+      direction: "callers"
+    });
+    const directEdge = callers.find((edge) => edge.fromSymbolName === from);
+    if (directEdge) {
+      const location = directEdge.fromSymbolFilePath ? ` at ${directEdge.fromSymbolFilePath}:${directEdge.line}` : "";
+      const fitted2 = fitTextToContextBudget(
+        `Direct path: ${from} --${directEdge.callType}--> ${to}${location} (edge is ${directEdge.isResolved ? "resolved" : "unresolved"}).`,
+        tokenBudget
+      );
+      return {
+        text: fitted2.text,
+        details: fittedDetails("direct-edge", fitted2)
+      };
+    }
+    const fitted = fitTextToContextBudget(
+      formatCallGraphPath(from, to, path17),
+      tokenBudget
+    );
+    return {
+      text: fitted.text,
+      details: fittedDetails("path", fitted)
+    };
+  }
+  return resolveSearchContext({ query: input.query, symbol, limit, tokenBudget }, {
+    lookup: (lookupSymbol, retrievalLimit) => implementationLookup(projectRoot3, host, lookupSymbol, {
+      limit: retrievalLimit,
+      fileType,
+      directory
+    }),
+    search: (query, retrievalLimit) => searchCodebase(projectRoot3, host, query, {
+      limit: retrievalLimit,
+      fileType,
+      directory,
+      metadataOnly: true
+    })
+  });
+}
+
 // src/pi-call-graph.ts
 var import_typebox = require("typebox");
 var HOST = "pi";
@@ -10675,58 +11551,33 @@ function codebaseIndexPiExtension(pi) {
   pi.registerTool({
     name: "codebase_context",
     label: "Codebase Context",
-    description: "PREFERRED FIRST TOOL for any repository question. Check index_status when freshness is unknown, then use this tool for low-token location discovery and dependency flow.",
+    description: "PREFERRED FIRST TOOL for any repository question. Returns a deduplicated, file-diverse evidence pack within tokenBudget. Check index_status when freshness is unknown, then use this tool for low-token location discovery and dependency flow.",
     parameters: import_typebox2.Type.Object({
       query: import_typebox2.Type.String({ description: "Natural language description of what code you're trying to locate" }),
-      from: import_typebox2.Type.Optional(import_typebox2.Type.String({ description: "Source symbol when asking for a dependency path." })),
-      to: import_typebox2.Type.Optional(import_typebox2.Type.String({ description: "Target symbol when asking for a dependency path." })),
-      symbol: import_typebox2.Type.Optional(import_typebox2.Type.String({ description: "Exact symbol name for an authoritative definition lookup." })),
-      limit: import_typebox2.Type.Optional(import_typebox2.Type.Number({ description: "Maximum results (default: 10)" })),
-      maxDepth: import_typebox2.Type.Optional(import_typebox2.Type.Number({ description: "Maximum call-graph traversal depth for from/to paths" })),
-      fileType: import_typebox2.Type.Optional(import_typebox2.Type.String({ description: "Filter by file extension, e.g., ts, py, rs" })),
-      directory: import_typebox2.Type.Optional(import_typebox2.Type.String({ description: "Filter by directory path" }))
+      from: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()], { description: "Source symbol when asking for a dependency path." })),
+      to: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()], { description: "Target symbol when asking for a dependency path." })),
+      symbol: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()], { description: "Exact symbol name for an authoritative definition lookup." })),
+      limit: import_typebox2.Type.Optional(import_typebox2.Type.Union([
+        import_typebox2.Type.Integer({ minimum: MIN_CONTEXT_RESULT_LIMIT, maximum: MAX_CONTEXT_RESULT_LIMIT }),
+        import_typebox2.Type.Null()
+      ], { default: 10, description: `Maximum results (${MIN_CONTEXT_RESULT_LIMIT}-${MAX_CONTEXT_RESULT_LIMIT})` })),
+      maxDepth: import_typebox2.Type.Optional(import_typebox2.Type.Union([
+        import_typebox2.Type.Integer({ minimum: MIN_CONTEXT_PATH_DEPTH, maximum: MAX_CONTEXT_PATH_DEPTH }),
+        import_typebox2.Type.Null()
+      ], { default: 10, description: `Maximum call-graph traversal depth (${MIN_CONTEXT_PATH_DEPTH}-${MAX_CONTEXT_PATH_DEPTH})` })),
+      fileType: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()], { description: "Filter by file extension, e.g., ts, py, rs" })),
+      directory: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()], { description: "Filter by directory path" })),
+      tokenBudget: import_typebox2.Type.Optional(import_typebox2.Type.Union([
+        import_typebox2.Type.Integer({ minimum: MIN_CONTEXT_PACK_TOKEN_BUDGET, maximum: MAX_CONTEXT_PACK_TOKEN_BUDGET }),
+        import_typebox2.Type.Null()
+      ], {
+        default: DEFAULT_CONTEXT_PACK_TOKEN_BUDGET,
+        description: `Maximum response tokens (${MIN_CONTEXT_PACK_TOKEN_BUDGET}-${MAX_CONTEXT_PACK_TOKEN_BUDGET})`
+      }))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const root = projectRoot2(ctx);
-      if (params.from && params.to) {
-        const path17 = await getCallGraphPath(root, HOST2, params.from, params.to, params.maxDepth);
-        if (path17.length > 0) {
-          return text2(formatCallGraphPath(params.from, params.to, path17), path17);
-        }
-        const { callers } = await getCallGraphData(root, HOST2, {
-          name: params.to,
-          direction: "callers"
-        });
-        const directEdge = callers.find((edge) => edge.fromSymbolName === params.from);
-        if (directEdge) {
-          const location = directEdge.fromSymbolFilePath ? ` at ${directEdge.fromSymbolFilePath}:${directEdge.line}` : "";
-          return text2(
-            `Direct path: ${params.from} --${directEdge.callType}--> ${params.to}${location} (edge is ${directEdge.isResolved ? "resolved" : "unresolved"}).`,
-            path17
-          );
-        }
-        return text2(formatCallGraphPath(params.from, params.to, path17), path17);
-      }
-      if (params.symbol) {
-        const results2 = await implementationLookup(root, HOST2, params.symbol, {
-          limit: params.limit ?? 10,
-          fileType: params.fileType,
-          directory: params.directory
-        });
-        return text2(formatDefinitionLookup(results2, params.symbol), results2);
-      }
-      const results = await searchCodebase(root, HOST2, params.query, {
-        limit: params.limit ?? 10,
-        fileType: params.fileType,
-        directory: params.directory,
-        metadataOnly: true
-      });
-      if (results.length === 0) {
-        return text2("No matching code found. Try a different query or run index_status/index_codebase first.");
-      }
-      return text2(`Found ${results.length} locations for "${params.query}":
-
-${formatCodebasePeek(results)}`, results);
+      const result = await resolveCodebaseContext(projectRoot2(ctx), HOST2, params);
+      return text2(result.text, result.details);
     }
   });
   pi.registerTool({