bluera-knowledge 0.28.0 → 0.29.0

package/dist/{chunk-WP2GERAJ.js → chunk-U27UECDZ.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-CLIMKLTW.js";
 import {
   parseIgnorePatternsForScanning
-} from "./chunk-H25AEF47.js";
+} from "./chunk-7JTPAQFO.js";
 import {
   __require
 } from "./chunk-DGUM43GV.js";
@@ -2060,8 +2060,601 @@ var CodeGraphService = class {
 
 // src/services/config.service.ts
 import { readFile as readFile2, access } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { isAbsolute, join as join6, resolve } from "path";
+
+// src/services/reranker-env.ts
+var logger = createLogger("reranker-env");
+function parseRerankerEnvOverrides(strict) {
+  return {
+    enabled: parseEnabled(process.env["BK_RERANKER_ENABLED"], strict),
+    topK: parseTopK(process.env["BK_RERANKER_TOPK"], strict)
+  };
+}
+function parseEnabled(raw, strict) {
+  if (raw === void 0 || raw === "") return void 0;
+  if (raw === "1") return true;
+  if (raw === "0") return false;
+  const msg = `BK_RERANKER_ENABLED must be '0' or '1', got: "${raw}"`;
+  if (strict) throw new Error(msg);
+  logger.warn(msg);
+  return void 0;
+}
+function parseTopK(raw, strict) {
+  if (raw === void 0 || raw === "") return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isNaN(parsed) || parsed < 1) {
+    const msg = `BK_RERANKER_TOPK must be a positive integer, got: "${raw}"`;
+    if (strict) throw new Error(msg);
+    logger.warn(msg);
+    return void 0;
+  }
+  return parsed;
+}
+
+// src/db/embeddings.ts
 import { homedir } from "os";
-import { isAbsolute, join as join5, resolve } from "path";
+import { join as join5 } from "path";
+import { pipeline, env } from "@huggingface/transformers";
+
+// src/models/registry.ts
+var MODEL_REGISTRY = {
+  // ============================================================
+  // BGE Models (BAAI) - Best for retrieval tasks
+  // ============================================================
+  "bge-small-en-v1.5": {
+    id: "Xenova/bge-small-en-v1.5",
+    name: "BGE Small English v1.5",
+    dimensions: 384,
+    pooling: "cls",
+    normalize: true,
+    queryPrefix: "Represent this sentence for searching relevant passages: ",
+    docPrefix: "",
+    category: "bge",
+    sizeCategory: "small",
+    notes: "Default model. Best balance of speed and quality for code search."
+  },
+  "bge-base-en-v1.5": {
+    id: "Xenova/bge-base-en-v1.5",
+    name: "BGE Base English v1.5",
+    dimensions: 768,
+    pooling: "cls",
+    normalize: true,
+    queryPrefix: "Represent this sentence for searching relevant passages: ",
+    docPrefix: "",
+    category: "bge",
+    sizeCategory: "base",
+    notes: "53% slower than small. Tested: regression on code search."
+  },
+  "bge-large-en-v1.5": {
+    id: "Xenova/bge-large-en-v1.5",
+    name: "BGE Large English v1.5",
+    dimensions: 1024,
+    pooling: "cls",
+    normalize: true,
+    queryPrefix: "Represent this sentence for searching relevant passages: ",
+    docPrefix: "",
+    category: "bge",
+    sizeCategory: "large",
+    notes: "Highest quality BGE but slow. Use for accuracy-critical tasks."
+  },
+  "bge-small-en": {
+    id: "Xenova/bge-small-en",
+    name: "BGE Small English v1.0",
+    dimensions: 384,
+    pooling: "cls",
+    normalize: true,
+    queryPrefix: "Represent this sentence for searching relevant passages: ",
+    docPrefix: "",
+    category: "bge",
+    sizeCategory: "small",
+    notes: "Older version. Use v1.5 instead."
+  },
+  "bge-base-en": {
+    id: "Xenova/bge-base-en",
+    name: "BGE Base English v1.0",
+    dimensions: 768,
+    pooling: "cls",
+    normalize: true,
+    queryPrefix: "Represent this sentence for searching relevant passages: ",
+    docPrefix: "",
+    category: "bge",
+    sizeCategory: "base",
+    notes: "Older version. Use v1.5 instead."
+  },
+  // ============================================================
+  // E5 Models (Microsoft) - Asymmetric retrieval
+  // ============================================================
+  "e5-small-v2": {
+    id: "Xenova/e5-small-v2",
+    name: "E5 Small v2",
+    dimensions: 384,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "query: ",
+    docPrefix: "passage: ",
+    category: "e5",
+    sizeCategory: "small",
+    notes: "Tested: underperformed BGE on code search. Better for general text."
+  },
+  "e5-base-v2": {
+    id: "Xenova/e5-base-v2",
+    name: "E5 Base v2",
+    dimensions: 768,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "query: ",
+    docPrefix: "passage: ",
+    category: "e5",
+    sizeCategory: "base",
+    notes: 'Larger E5 variant. Requires "query:" and "passage:" prefixes.'
+  },
+  "e5-large-v2": {
+    id: "Xenova/e5-large-v2",
+    name: "E5 Large v2",
+    dimensions: 1024,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "query: ",
+    docPrefix: "passage: ",
+    category: "e5",
+    sizeCategory: "large",
+    notes: "Highest quality E5. Slow but accurate for general retrieval."
+  },
+  "multilingual-e5-small": {
+    id: "Xenova/multilingual-e5-small",
+    name: "Multilingual E5 Small",
+    dimensions: 384,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "query: ",
+    docPrefix: "passage: ",
+    category: "e5",
+    sizeCategory: "small",
+    notes: "Supports 100+ languages. Good for multilingual codebases."
+  },
+  "multilingual-e5-base": {
+    id: "Xenova/multilingual-e5-base",
+    name: "Multilingual E5 Base",
+    dimensions: 768,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "query: ",
+    docPrefix: "passage: ",
+    category: "e5",
+    sizeCategory: "base",
+    notes: "Supports 100+ languages. Larger multilingual variant."
+  },
+  // ============================================================
+  // MiniLM Models (Sentence Transformers) - Fast general-purpose
+  // ============================================================
+  "all-MiniLM-L6-v2": {
+    id: "Xenova/all-MiniLM-L6-v2",
+    name: "all-MiniLM-L6-v2",
+    dimensions: 384,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "",
+    docPrefix: "",
+    category: "minilm",
+    sizeCategory: "small",
+    notes: "Popular universal model. No prefixes needed. Very fast."
+  },
+  "all-MiniLM-L12-v2": {
+    id: "Xenova/all-MiniLM-L12-v2",
+    name: "all-MiniLM-L12-v2",
+    dimensions: 384,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "",
+    docPrefix: "",
+    category: "minilm",
+    sizeCategory: "small",
+    notes: "Deeper MiniLM. Slightly better quality than L6."
+  },
+  "paraphrase-MiniLM-L6-v2": {
+    id: "Xenova/paraphrase-MiniLM-L6-v2",
+    name: "paraphrase-MiniLM-L6-v2",
+    dimensions: 384,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "",
+    docPrefix: "",
+    category: "minilm",
+    sizeCategory: "small",
+    notes: "Optimized for paraphrase detection. Good for similarity."
+  },
+  "multi-qa-MiniLM-L6-cos-v1": {
+    id: "Xenova/multi-qa-MiniLM-L6-cos-v1",
+    name: "multi-qa-MiniLM-L6-cos-v1",
+    dimensions: 384,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "",
+    docPrefix: "",
+    category: "minilm",
+    sizeCategory: "small",
+    notes: "Trained on 215M QA pairs. Good for question answering."
+  },
+  // ============================================================
+  // GTE Models (Alibaba) - State-of-the-art small models
+  // ============================================================
+  "gte-small": {
+    id: "Xenova/gte-small",
+    name: "GTE Small",
+    dimensions: 384,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "",
+    docPrefix: "",
+    category: "gte",
+    sizeCategory: "small",
+    notes: "Competitive with larger models. No prefixes needed."
+  },
+  "gte-base": {
+    id: "Xenova/gte-base",
+    name: "GTE Base",
+    dimensions: 768,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "",
+    docPrefix: "",
+    category: "gte",
+    sizeCategory: "base",
+    notes: "Strong performance on MTEB benchmark."
+  },
+  "gte-large": {
+    id: "Xenova/gte-large",
+    name: "GTE Large",
+    dimensions: 1024,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "",
+    docPrefix: "",
+    category: "gte",
+    sizeCategory: "large",
+    notes: "Top MTEB scores. Slow but very accurate."
+  },
+  // ============================================================
+  // Nomic Models - Long context support
+  // ============================================================
+  "nomic-embed-text-v1": {
+    id: "nomic-ai/nomic-embed-text-v1",
+    name: "Nomic Embed Text v1",
+    dimensions: 768,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "search_query: ",
+    docPrefix: "search_document: ",
+    category: "nomic",
+    sizeCategory: "base",
+    notes: "8192 token context. May need trust_remote_code."
+  },
+  "nomic-embed-text-v1.5": {
+    id: "nomic-ai/nomic-embed-text-v1.5",
+    name: "Nomic Embed Text v1.5",
+    dimensions: 768,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "search_query: ",
+    docPrefix: "search_document: ",
+    category: "nomic",
+    sizeCategory: "base",
+    notes: "8192 token context. Matryoshka embeddings support."
+  },
+  // ============================================================
+  // Other Notable Models
+  // ============================================================
+  "jina-embeddings-v2-small-en": {
+    id: "Xenova/jina-embeddings-v2-small-en",
+    name: "Jina Embeddings v2 Small",
+    dimensions: 512,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "",
+    docPrefix: "",
+    category: "other",
+    sizeCategory: "small",
+    notes: "8192 token context. Good for long documents."
+  },
+  "jina-embeddings-v2-base-en": {
+    id: "Xenova/jina-embeddings-v2-base-en",
+    name: "Jina Embeddings v2 Base",
+    dimensions: 768,
+    pooling: "mean",
+    normalize: true,
+    queryPrefix: "",
+    docPrefix: "",
+    category: "other",
+    sizeCategory: "base",
+    notes: "8192 token context. Larger Jina variant."
+  }
+};
+var DEFAULT_MODEL_ID = "bge-small-en-v1.5";
+function getModelConfig(modelId) {
+  if (modelId in MODEL_REGISTRY) {
+    return MODEL_REGISTRY[modelId];
+  }
+  for (const config of Object.values(MODEL_REGISTRY)) {
+    if (config.id === modelId) {
+      return config;
+    }
+  }
+  return void 0;
+}
+function getConfiguredModelId() {
+  const envModel = process.env["BK_MODEL"] ?? process.env["BK_EMBEDDING_MODEL"];
+  if (envModel !== void 0 && envModel !== "") {
+    const config = getModelConfig(envModel);
+    if (config === void 0) {
+      console.warn(`Warning: Unknown model "${envModel}", using default "${DEFAULT_MODEL_ID}"`);
+      return DEFAULT_MODEL_ID;
+    }
+    return envModel;
+  }
+  return DEFAULT_MODEL_ID;
+}
+
+// src/db/embeddings.ts
+env.cacheDir = join5(homedir(), ".cache", "huggingface-transformers");
+function getFinetunedModelPath() {
+  const path4 = process.env["BK_FINETUNED_MODEL"];
+  if (path4 !== void 0 && path4 !== "") {
+    return path4;
+  }
+  return void 0;
+}
+function buildEmbeddingConfig(modelId, overrides) {
+  const rawPooling = process.env["BK_POOLING"];
+  const envPooling = rawPooling === "mean" || rawPooling === "cls" || rawPooling === "none" ? rawPooling : void 0;
+  const envQueryPrefix = process.env["BK_QUERY_PREFIX"];
+  const modelConfig = getModelConfig(modelId);
+  if (modelConfig === void 0) {
+    return {
+      model: modelId,
+      batchSize: overrides?.batchSize ?? 32,
+      dtype: overrides?.dtype ?? "fp32",
+      pooling: overrides?.pooling ?? envPooling ?? "mean",
+      normalize: overrides?.normalize ?? true,
+      queryPrefix: overrides?.queryPrefix ?? envQueryPrefix ?? "",
+      docPrefix: overrides?.docPrefix ?? "",
+      maxInFlightBatches: overrides?.maxInFlightBatches ?? 1
+    };
+  }
+  return {
+    model: modelConfig.id,
+    batchSize: overrides?.batchSize ?? 32,
+    dtype: overrides?.dtype ?? "fp32",
+    pooling: overrides?.pooling ?? envPooling ?? modelConfig.pooling,
+    normalize: overrides?.normalize ?? modelConfig.normalize,
+    queryPrefix: overrides?.queryPrefix ?? envQueryPrefix ?? modelConfig.queryPrefix,
+    docPrefix: overrides?.docPrefix ?? modelConfig.docPrefix,
+    maxInFlightBatches: overrides?.maxInFlightBatches ?? 1
+  };
+}
+var DEFAULT_EMBEDDING_CONFIG = buildEmbeddingConfig(
+  getFinetunedModelPath() ?? getConfiguredModelId()
+);
+var EmbeddingEngine = class {
+  extractor = null;
+  initPromise = null;
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly -- mutated in embed() and embedBatch()
+  _dimensions = null;
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly -- mutated in dispose()
+  disposed = false;
+  config;
+  constructor(config = DEFAULT_EMBEDDING_CONFIG) {
+    if (process.env["BK_DEBUG"] !== void 0 && process.env["BK_DEBUG"] !== "") {
+      console.log("[EmbeddingEngine] Using model:", config.model);
+    }
+    this.config = config;
+  }
+  /**
+   * Guard against use-after-dispose
+   */
+  assertNotDisposed() {
+    if (this.disposed) {
+      throw new Error("EmbeddingEngine has been disposed");
+    }
+  }
+  /**
+   * Initialize the embedding pipeline (concurrency-safe).
+   * Multiple concurrent calls will share the same initialization promise.
+   */
+  async initialize() {
+    this.assertNotDisposed();
+    if (this.extractor !== null) return;
+    this.initPromise ??= (async () => {
+      try {
+        this.extractor = await pipeline("feature-extraction", this.config.model, {
+          dtype: this.config.dtype
+        });
+      } catch (error) {
+        this.initPromise = null;
+        throw error;
+      }
+    })();
+    await this.initPromise;
+  }
+  /**
+   * Embed a search query. Applies queryPrefix for asymmetric models.
+   */
+  async embedQuery(text) {
+    return this.embedText(this.config.queryPrefix + text);
+  }
+  /**
+   * Embed a document for indexing. Applies docPrefix for asymmetric models.
+   */
+  async embedDocument(text) {
+    return this.embedText(this.config.docPrefix + text);
+  }
+  /**
+   * Internal: embed text without prefix.
+   */
+  async embedText(text) {
+    this.assertNotDisposed();
+    if (this.extractor === null) {
+      await this.initialize();
+    }
+    if (this.extractor === null) {
+      throw new Error("Failed to initialize embedding model");
+    }
+    const output = await this.extractor(text, {
+      pooling: this.config.pooling,
+      normalize: this.config.normalize
+    });
+    const dim = output.dims[output.dims.length - 1] ?? 0;
+    this._dimensions ??= dim;
+    return Float32Array.from(output.data);
+  }
+  /**
+   * Embed a batch of documents with optional parallelism.
+   * When maxInFlightBatches > 1, processes multiple batches concurrently.
+   */
+  async embedBatch(texts) {
+    this.assertNotDisposed();
+    if (this.extractor === null) {
+      await this.initialize();
+    }
+    if (this.extractor === null) {
+      throw new Error("Failed to initialize embedding model");
+    }
+    const batches = [];
+    for (let i = 0; i < texts.length; i += this.config.batchSize) {
+      batches.push(texts.slice(i, i + this.config.batchSize));
+    }
+    if (batches.length === 0) {
+      return [];
+    }
+    if (this.config.maxInFlightBatches <= 1) {
+      return this.embedBatchesSequential(batches);
+    } else {
+      return this.embedBatchesConcurrent(batches);
+    }
+  }
+  /**
+   * Process batches sequentially (original behavior).
+   */
+  async embedBatchesSequential(batches) {
+    const results = [];
+    for (let i = 0; i < batches.length; i++) {
+      const batch = batches[i];
+      if (batch === void 0) continue;
+      const batchResults = await this.processSingleBatch(batch);
+      results.push(...batchResults);
+      if (i < batches.length - 1) {
+        await new Promise((resolve4) => setImmediate(resolve4));
+      }
+    }
+    return results;
+  }
+  /**
+   * Process batches with controlled concurrency.
+   */
+  async embedBatchesConcurrent(batches) {
+    const results = new Array(batches.length);
+    let inFlight = 0;
+    const maxConcurrent = this.config.maxInFlightBatches;
+    await Promise.all(
+      batches.map(async (batch, idx) => {
+        while (inFlight >= maxConcurrent) {
+          await new Promise((resolve4) => setImmediate(resolve4));
+        }
+        inFlight++;
+        try {
+          results[idx] = await this.processSingleBatch(batch);
+        } finally {
+          inFlight--;
+        }
+      })
+    );
+    return results.flat();
+  }
+  /**
+   * Process a single batch and return embeddings.
+   */
+  async processSingleBatch(batch) {
+    if (this.extractor === null) {
+      throw new Error("Extractor not initialized");
+    }
+    const prefixedBatch = batch.map((text) => this.config.docPrefix + text);
+    const output = await this.extractor(prefixedBatch, {
+      pooling: this.config.pooling,
+      normalize: this.config.normalize
+    });
+    const dim = output.dims[output.dims.length - 1] ?? 0;
+    const batchResults = [];
+    for (let b = 0; b < batch.length; b++) {
+      const start = b * dim;
+      const end = start + dim;
+      batchResults.push(Float32Array.from(output.data.slice(start, end)));
+    }
+    this._dimensions ??= dim;
+    return batchResults;
+  }
+  /**
+   * Get cached embedding dimensions. Throws if embed() hasn't been called yet.
+   * Use ensureDimensions() if you need to guarantee dimensions are available.
+   */
+  getDimensions() {
+    if (this._dimensions === null) {
+      throw new Error("Cannot get dimensions before first embed() call");
+    }
+    return this._dimensions;
+  }
+  /**
+   * Check if the embedding pipeline is initialized.
+   */
+  isInitialized() {
+    return this.extractor !== null;
+  }
+  /**
+   * Check if this engine has been disposed.
+   */
+  isDisposed() {
+    return this.disposed;
+  }
+  /**
+   * Reset the engine to uninitialized state, allowing reuse after disposal.
+   * If currently initialized, disposes the pipeline first.
+   */
+  async reset() {
+    if (this.extractor !== null) {
+      await this.extractor.dispose();
+      this.extractor = null;
+    }
+    this.initPromise = null;
+    this._dimensions = null;
+    this.disposed = false;
+  }
+  /**
+   * Ensure dimensions are available, initializing the model if needed.
+   * Returns the embedding dimensions for the current model.
+   */
+  async ensureDimensions() {
+    if (this._dimensions === null) {
+      await this.embedText("dimension probe");
+    }
+    if (this._dimensions === null) {
+      throw new Error("Failed to determine embedding dimensions");
+    }
+    return this._dimensions;
+  }
+  /**
+   * Dispose the embedding pipeline to free resources.
+   * Should be called before process exit to prevent ONNX runtime cleanup issues on macOS.
+   * After disposal, this engine cannot be used again.
+   */
+  async dispose() {
+    if (this.extractor !== null) {
+      await this.extractor.dispose();
+      this.extractor = null;
+    }
+    this.initPromise = null;
+    this._dimensions = null;
+    this.disposed = true;
+  }
+};
 
 // src/types/config.ts
 var DEFAULT_CONFIG = {
@@ -2082,6 +2675,7 @@ var DEFAULT_CONFIG = {
     chunkSize: 1e3,
     chunkOverlap: 150,
     ignorePatterns: ["node_modules/**", ".git/**", "*.min.js", "*.map"],
+    prependPath: false,
     maxFileSizeBytes: 1048576
     // 1MB
   },
@@ -2097,6 +2691,12 @@ var DEFAULT_CONFIG = {
   server: {
     port: 3847,
     host: "127.0.0.1"
+  },
+  reranker: {
+    enabled: false,
+    model: "Xenova/ms-marco-MiniLM-L-6-v2",
+    topK: 20,
+    returnK: 10
   }
 };
 
@@ -2148,7 +2748,7 @@ var ConfigService = class {
     if (configPath !== void 0 && configPath !== "") {
       this.configPath = this.expandPath(configPath, this.projectRoot);
     } else {
-      this.configPath = join5(this.projectRoot, DEFAULT_CONFIG_PATH);
+      this.configPath = join6(this.projectRoot, DEFAULT_CONFIG_PATH);
     }
     if (dataDir !== void 0 && dataDir !== "") {
       this.dataDir = this.expandPath(dataDir, this.projectRoot);
@@ -2170,15 +2770,60 @@ var ConfigService = class {
     if (!exists) {
       this.config = { ...DEFAULT_CONFIG };
       await this.save(this.config);
-      return this.config;
+    } else {
+      const content = await readFile2(this.configPath, "utf-8");
+      try {
+        this.config = deepMerge(DEFAULT_CONFIG, JSON.parse(content));
+      } catch (error) {
+        throw new Error(
+          `Failed to parse config file at ${this.configPath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
     }
-    const content = await readFile2(this.configPath, "utf-8");
-    try {
-      this.config = deepMerge(DEFAULT_CONFIG, JSON.parse(content));
-    } catch (error) {
-      throw new Error(
-        `Failed to parse config file at ${this.configPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
+    const finetunedPath = getFinetunedModelPath();
+    if (finetunedPath !== void 0) {
+      this.config = {
+        ...this.config,
+        embedding: buildEmbeddingConfig(finetunedPath, {
+          batchSize: this.config.embedding.batchSize,
+          maxInFlightBatches: this.config.embedding.maxInFlightBatches
+        })
+      };
+    } else {
+      const configuredModelId = getConfiguredModelId();
+      if (configuredModelId !== this.config.embedding.model) {
+        this.config = {
+          ...this.config,
+          embedding: buildEmbeddingConfig(configuredModelId, {
+            batchSize: this.config.embedding.batchSize,
+            maxInFlightBatches: this.config.embedding.maxInFlightBatches
+          })
+        };
+      }
+    }
+    const rawPooling = process.env["BK_POOLING"];
+    const envPooling = rawPooling === "mean" || rawPooling === "cls" || rawPooling === "none" ? rawPooling : void 0;
+    const envQueryPrefix = process.env["BK_QUERY_PREFIX"];
+    if (envPooling !== void 0 || envQueryPrefix !== void 0) {
+      this.config = {
+        ...this.config,
+        embedding: {
+          ...this.config.embedding,
+          ...envPooling !== void 0 ? { pooling: envPooling } : {},
+          ...envQueryPrefix !== void 0 ? { queryPrefix: envQueryPrefix } : {}
+        }
+      };
+    }
+    const rerankerOverrides = parseRerankerEnvOverrides(false);
+    if (rerankerOverrides.enabled !== void 0 || rerankerOverrides.topK !== void 0) {
+      this.config = {
+        ...this.config,
+        reranker: {
+          ...this.config.reranker,
+          ...rerankerOverrides.enabled !== void 0 ? { enabled: rerankerOverrides.enabled } : {},
+          ...rerankerOverrides.topK !== void 0 ? { topK: rerankerOverrides.topK } : {}
+        }
+      };
     }
     return this.config;
   }
@@ -2194,7 +2839,7 @@ var ConfigService = class {
   }
   expandPath(path4, baseDir) {
     if (path4.startsWith("~")) {
-      return path4.replace("~", homedir());
+      return path4.replace("~", homedir2());
     }
     if (!isAbsolute(path4)) {
       return resolve(baseDir, path4);
@@ -2205,19 +2850,38 @@ var ConfigService = class {
 
 // src/services/gitignore.service.ts
 import { readFile as readFile3, writeFile as writeFile3, access as access2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var REQUIRED_PATTERNS = [
-  ".bluera/*",
+  ".bluera/",
+  "!.bluera/",
   "!.bluera/bluera-knowledge/",
-  ".bluera/bluera-knowledge/*",
   "!.bluera/bluera-knowledge/stores.config.json",
   "!.bluera/bluera-knowledge/config.json",
   "!.bluera/bluera-knowledge/skill-activation.json",
   ".bluera/bluera-knowledge/data/",
   ".bluera/bluera-knowledge/logs/"
 ];
-var SECTION_BEGIN = "# BEGIN Bluera Knowledge";
-var SECTION_END = "# END Bluera Knowledge";
+function isPatternCovered(pattern, existingLines) {
+  if (existingLines.includes(pattern)) return true;
+  if (pattern.endsWith("/")) {
+    const withoutSlash = pattern.slice(0, -1);
+    if (existingLines.includes(withoutSlash)) return true;
+  } else {
+    if (existingLines.includes(`${pattern}/`)) return true;
+  }
+  if (pattern === ".bluera/") {
+    if (existingLines.includes(".bluera/*")) return true;
+  }
+  if (pattern === "!.bluera/") {
+    if (existingLines.includes(".bluera/*")) return true;
+  }
+  return false;
+}
+var SECTION_HEADER = `
+# Bluera Knowledge
+# Config files (stores.config.json, config.json, skill-activation.json) can be committed
+# Data directory (vector DB, cloned repos) and logs are not committed
+`;
 async function fileExists2(path4) {
   try {
     await access2(path4);
@@ -2226,73 +2890,13 @@ async function fileExists2(path4) {
     return false;
   }
 }
-function isPatternSatisfied(requiredPattern, existingLines) {
-  if (existingLines.includes(requiredPattern)) {
-    return true;
-  }
-  switch (requiredPattern) {
-    case ".bluera/*":
-      return existingLines.includes(".bluera/");
-    case "!.bluera/bluera-knowledge/":
-      return existingLines.includes("!.bluera/bluera-knowledge");
-    case ".bluera/bluera-knowledge/data/":
-    case ".bluera/bluera-knowledge/logs/":
-      return existingLines.includes(".bluera/bluera-knowledge/*");
-    default:
-      return false;
-  }
-}
-function removeBkSection(content) {
-  const lines = content.split("\n");
-  const outputLines = [];
-  let removed = false;
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i] ?? "";
-    const trimmed = line.trim();
-    if (trimmed === SECTION_BEGIN) {
-      removed = true;
-      i++;
-      while (i < lines.length && (lines[i] ?? "").trim() !== SECTION_END) {
-        i++;
-      }
-      if (i < lines.length) {
-        i++;
-      }
-      continue;
-    }
-    if (trimmed === "# Bluera Knowledge") {
-      removed = true;
-      i++;
-      while (i < lines.length) {
-        const lt = (lines[i] ?? "").trim();
-        if (lt === "" || lt.startsWith("#") || lt.includes(".bluera")) {
-          i++;
-        } else {
-          break;
-        }
-      }
-      continue;
-    }
-    outputLines.push(line);
-    i++;
-  }
-  let lastIdx = outputLines.length - 1;
-  while (lastIdx >= 0 && outputLines[lastIdx]?.trim() === "") {
-    outputLines.pop();
-    lastIdx--;
-  }
-  const cleaned = outputLines.length > 0 ? `${outputLines.join("\n")}
-` : "";
-  return { cleaned, removed };
-}
 var GitignoreService = class {
   gitignorePath;
   constructor(projectRoot) {
-    this.gitignorePath = join6(projectRoot, ".gitignore");
+    this.gitignorePath = join7(projectRoot, ".gitignore");
   }
   /**
-   * Check if all required patterns are semantically present in .gitignore
+   * Check if all required patterns are present in .gitignore
    */
   async hasRequiredPatterns() {
     const exists = await fileExists2(this.gitignorePath);
@@ -2301,62 +2905,52 @@ var GitignoreService = class {
     }
     const content = await readFile3(this.gitignorePath, "utf-8");
     const lines = content.split("\n").map((l) => l.trim());
-    return REQUIRED_PATTERNS.every((pattern) => isPatternSatisfied(pattern, lines));
+    for (const pattern of REQUIRED_PATTERNS) {
+      if (!isPatternCovered(pattern, lines)) {
+        return false;
+      }
+    }
+    return true;
   }
   /**
    * Ensure required .gitignore patterns are present.
    *
    * - Creates .gitignore if it doesn't exist
-   * - Removes existing managed sections (old or new format)
-   * - Appends only semantically missing patterns with BEGIN/END markers
-   * - Persists cleanup even when no patterns are missing
+   * - Appends missing patterns if .gitignore exists
+   * - Does nothing if all patterns are already present
    *
    * @returns Object with updated flag and descriptive message
    */
   async ensureGitignorePatterns() {
     const exists = await fileExists2(this.gitignorePath);
     if (!exists) {
-      const content = [SECTION_BEGIN, ...REQUIRED_PATTERNS, SECTION_END, ""].join("\n");
+      const content = `${SECTION_HEADER.trim()}
+${REQUIRED_PATTERNS.join("\n")}
+`;
       await writeFile3(this.gitignorePath, content);
       return {
         updated: true,
         message: "Created .gitignore with Bluera Knowledge patterns"
       };
     }
-    let rawContent = await readFile3(this.gitignorePath, "utf-8");
-    rawContent = rawContent.replace(/\r\n/g, "\n");
-    const { cleaned, removed } = removeBkSection(rawContent);
-    const cleanedLines = cleaned.split("\n").map((l) => l.trim());
+    const existingContent = await readFile3(this.gitignorePath, "utf-8");
+    const lines = existingContent.split("\n").map((l) => l.trim());
     const missingPatterns = REQUIRED_PATTERNS.filter(
-      (pattern) => !isPatternSatisfied(pattern, cleanedLines)
+      (pattern) => !isPatternCovered(pattern, lines)
     );
     if (missingPatterns.length === 0) {
-      if (removed) {
-        await writeFile3(this.gitignorePath, cleaned);
-        return {
-          updated: true,
-          message: "Cleaned redundant Bluera Knowledge section from .gitignore"
-        };
-      }
       return {
         updated: false,
         message: "All Bluera Knowledge patterns already present in .gitignore"
       };
     }
-    let newContent = cleaned;
-    if (newContent.length > 0) {
-      if (!newContent.endsWith("\n")) {
-        newContent += "\n";
-      }
+    let newContent = existingContent;
+    if (!newContent.endsWith("\n")) {
       newContent += "\n";
     }
-    newContent += [SECTION_BEGIN, ...missingPatterns, SECTION_END, ""].join("\n");
-    if (newContent === rawContent) {
-      return {
-        updated: false,
-        message: "All Bluera Knowledge patterns already present in .gitignore"
-      };
-    }
+    newContent += SECTION_HEADER;
+    newContent += `${missingPatterns.join("\n")}
+`;
     await writeFile3(this.gitignorePath, newContent);
     return {
       updated: true,
@@ -2375,9 +2969,9 @@ var GitignoreService = class {
 import { execFile } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import { open, readFile as readFile5, readdir, stat as stat2 } from "fs/promises";
-import { join as join7, extname, basename, relative } from "path";
+import { join as join8, extname, basename, relative } from "path";
 import { promisify } from "util";
-import { minimatch } from "minimatch";
+import { minimatch as minimatchFn } from "minimatch";
 
 // src/services/chunking.service.ts
 var CHUNK_PRESETS = {
@@ -2759,8 +3353,9 @@ var DriftService = class {
 };
 
 // src/services/index.service.ts
+var minimatch = minimatchFn;
 var execFileAsync = promisify(execFile);
-var logger = createLogger("index-service");
+var logger2 = createLogger("index-service");
 var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
   // Text/docs
   ".txt",
@@ -2892,6 +3487,110 @@ async function isBinaryFile(filePath) {
     await fd.close();
   }
 }
+var EXT_TO_LANGUAGE = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".pyi": "python",
+  ".pyx": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".scala": "scala",
+  ".groovy": "groovy",
+  ".rb": "ruby",
+  ".erb": "ruby",
+  ".rake": "ruby",
+  ".php": "php",
+  ".swift": "swift",
+  ".m": "objective-c",
+  ".mm": "objective-c",
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".hxx": "cpp",
+  ".cs": "csharp",
+  ".fs": "fsharp",
+  ".vb": "vb",
+  ".sh": "shell",
+  ".bash": "shell",
+  ".zsh": "shell",
+  ".fish": "shell",
+  ".ps1": "powershell",
+  ".psm1": "powershell",
+  ".sql": "sql",
+  ".md": "markdown",
+  ".rst": "restructuredtext",
+  ".lua": "lua",
+  ".r": "r",
+  ".R": "r",
+  ".jl": "julia",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".hrl": "erlang",
+  ".clj": "clojure",
+  ".cljs": "clojure",
+  ".cljc": "clojure",
+  ".hs": "haskell",
+  ".elm": "elm",
+  ".dart": "dart",
+  ".zig": "zig",
+  ".nim": "nim",
+  ".v": "v",
+  ".pl": "perl",
+  ".pm": "perl",
+  ".tf": "terraform",
+  ".hcl": "hcl",
+  ".proto": "protobuf",
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".less": "less",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".xml": "xml"
+};
+var ENTRY_POINT_NAMES = /* @__PURE__ */ new Set([
+  "index.ts",
+  "index.js",
+  "index.mjs",
+  "index.tsx",
+  "index.jsx",
+  "main.ts",
+  "main.js",
+  "main.py",
+  "main.go",
+  "main.rs",
+  "app.ts",
+  "app.js",
+  "app.py",
+  "mod.rs",
+  "lib.rs",
+  "__init__.py",
+  "server.ts",
+  "server.js",
+  "server.py"
+]);
 var IndexService = class {
   lanceStore;
   embeddingEngine;
@@ -2902,6 +3601,7 @@ var IndexService = class {
   concurrency;
   ignoreDirs;
   ignoreFilePatterns;
+  prependPath;
   maxFileSizeBytes;
   constructor(lanceStore, embeddingEngine, options = {}) {
     this.lanceStore = lanceStore;
@@ -2914,13 +3614,14 @@ var IndexService = class {
     this.manifestService = options.manifestService;
     this.driftService = new DriftService();
     this.concurrency = options.concurrency ?? 4;
+    this.prependPath = options.prependPath ?? false;
     const parsed = parseIgnorePatternsForScanning(options.ignorePatterns ?? []);
     this.ignoreDirs = parsed.dirs;
     this.ignoreFilePatterns = parsed.fileMatchers;
     this.maxFileSizeBytes = options.maxFileSizeBytes ?? 1048576;
   }
   async indexStore(store, onProgress) {
-    logger.info(
+    logger2.info(
       {
         storeId: store.id,
         storeName: store.name,
@@ -2932,13 +3633,13 @@ var IndexService = class {
       if (store.type === "file" || store.type === "repo") {
         return await this.indexFileStore(store, onProgress);
       }
-      logger.error(
+      logger2.error(
         { storeId: store.id, storeType: store.type },
         "Unsupported store type for indexing"
       );
       return err(new Error(`Indexing not supported for store type: ${store.type}`));
     } catch (error) {
-      logger.error(
+      logger2.error(
         {
           storeId: store.id,
           error: error instanceof Error ? error.message : String(error)
@@ -2963,7 +3664,7 @@ var IndexService = class {
     if (store.type !== "file" && store.type !== "repo") {
       return err(new Error(`Incremental indexing not supported for store type: ${store.type}`));
     }
-    logger.info(
+    logger2.info(
       {
         storeId: store.id,
         storeName: store.name,
@@ -2979,7 +3680,7 @@ var IndexService = class {
         filePaths.map((path4) => this.driftService.getFileState(path4))
       );
       const drift = await this.driftService.detectChanges(manifest, currentFiles);
-      logger.debug(
+      logger2.debug(
         {
           storeId: store.id,
           added: drift.added.length,
@@ -2998,7 +3699,7 @@ var IndexService = class {
       }
       if (documentIdsToDelete.length > 0) {
         await this.lanceStore.deleteDocuments(store.id, documentIdsToDelete);
-        logger.debug(
+        logger2.debug(
           { storeId: store.id, count: documentIdsToDelete.length },
           "Deleted old documents"
         );
@@ -3034,7 +3735,7 @@ var IndexService = class {
                 fileState: state
               };
             } catch (error) {
-              logger.warn(
+              logger2.warn(
                 { filePath, error: error instanceof Error ? error.message : String(error) },
                 "Failed to process file during incremental indexing, skipping"
               );
@@ -3081,13 +3782,13 @@ var IndexService = class {
           if (allSourceFiles.length > 0) {
             const graph = await this.codeGraphService.buildGraph(allSourceFiles);
             await this.codeGraphService.saveGraph(store.id, graph);
-            logger.debug(
+            logger2.debug(
               { storeId: store.id, sourceFiles: allSourceFiles.length },
               "Rebuilt code graph during incremental indexing"
             );
           } else {
             await this.codeGraphService.deleteGraph(store.id);
-            logger.debug(
+            logger2.debug(
               { storeId: store.id },
               "Deleted stale code graph (no source files remain)"
             );
@@ -3108,7 +3809,7 @@ var IndexService = class {
         message: "Incremental indexing complete"
       });
       const timeMs = Date.now() - startTime;
-      logger.info(
+      logger2.info(
         {
           storeId: store.id,
           storeName: store.name,
@@ -3131,7 +3832,7 @@ var IndexService = class {
         filesUnchanged: drift.unchanged.length
       });
     } catch (error) {
-      logger.error(
+      logger2.error(
         {
           storeId: store.id,
           error: error instanceof Error ? error.message : String(error)
@@ -3150,7 +3851,7 @@ var IndexService = class {
     const files = await this.discoverFiles(store.path, store.ingest);
     const documents = [];
     let filesProcessed = 0;
-    logger.debug(
+    logger2.debug(
       {
         storeId: store.id,
         path: store.path,
@@ -3174,7 +3875,7 @@ var IndexService = class {
           try {
             return await this.processFile(filePath, store);
           } catch (error) {
-            logger.warn(
+            logger2.warn(
               { filePath, error: error instanceof Error ? error.message : String(error) },
               "Failed to process file, skipping"
             );
@@ -3189,11 +3890,19 @@ var IndexService = class {
         }
       }
       filesProcessed += batch.length;
+      const elapsedMs = Date.now() - startTime;
+      const filesPerSecond = elapsedMs > 0 ? filesProcessed / elapsedMs * 1e3 : 0;
+      const lastFile = batch.at(-1);
       onProgress?.({
         type: "progress",
         current: filesProcessed,
         total: files.length,
-        message: `Indexed ${String(filesProcessed)}/${String(files.length)} files`
+        message: `Indexed ${String(filesProcessed)}/${String(files.length)} files`,
+        details: {
+          ...lastFile !== void 0 ? { currentFile: basename(lastFile) } : {},
+          elapsedMs,
+          filesPerSecond
+        }
       });
     }
     if (documents.length > 0) {
@@ -3206,14 +3915,18 @@ var IndexService = class {
     } else if (this.codeGraphService) {
       await this.codeGraphService.deleteGraph(store.id);
     }
+    const timeMs = Date.now() - startTime;
     onProgress?.({
       type: "complete",
       current: files.length,
       total: files.length,
-      message: "Indexing complete"
+      message: "Indexing complete",
+      details: {
+        elapsedMs: timeMs,
+        filesPerSecond: timeMs > 0 ? files.length / timeMs * 1e3 : 0
+      }
     });
-    const timeMs = Date.now() - startTime;
-    logger.info(
+    logger2.info(
       {
         storeId: store.id,
         storeName: store.name,
@@ -3235,14 +3948,20 @@ var IndexService = class {
    * Extracted for parallel processing.
    */
   async processFile(filePath, store) {
-    const content = await readFile5(filePath, "utf-8");
-    const fileHash = createHash3("md5").update(content).digest("hex");
-    const chunks = this.chunker.chunk(content, filePath);
+    const rawContent = await readFile5(filePath, "utf-8");
+    const fileHash = createHash3("md5").update(rawContent).digest("hex");
     const relativePath = relative(store.path, filePath);
+    const content = this.prependPath ? `[${relativePath}]
+${rawContent}` : rawContent;
+    const chunks = this.chunker.chunk(content, filePath);
     const pathHash = createHash3("md5").update(relativePath).digest("hex").slice(0, 8);
     const ext = extname(filePath).toLowerCase();
     const fileName = basename(filePath).toLowerCase();
     const fileType = this.classifyFileType(ext, fileName, filePath);
+    const language = EXT_TO_LANGUAGE[ext];
+    const normalizedRelPath = relativePath.replaceAll("\\", "/");
+    const depth = normalizedRelPath.split("/").length - 1;
+    const isEntryPoint = ENTRY_POINT_NAMES.has(basename(filePath));
     const sourceFile = [".ts", ".tsx", ".js", ".jsx", ".py", ".rs", ".go"].includes(ext) ? { path: filePath, content } : void 0;
     if (chunks.length === 0) {
       return { documents: [], sourceFile };
@@ -3275,7 +3994,11 @@ var IndexService = class {
           sectionHeader: chunk.sectionHeader,
           functionName: chunk.functionName,
           hasDocComments: /\/\*\*[\s\S]*?\*\//.test(chunk.content),
-          docSummary: chunk.docSummary
+          docSummary: chunk.docSummary,
+          relativePath: normalizedRelPath,
+          language,
+          depth,
+          isEntryPoint
         }
       });
     }
@@ -3286,11 +4009,11 @@ var IndexService = class {
    */
   async getTrackedFiles(repoPath) {
     try {
-      const gitDir = join7(repoPath, ".git");
+      const gitDir = join8(repoPath, ".git");
       try {
         await stat2(gitDir);
       } catch {
-        logger.info({ repoPath }, "Not a git repository, using filesystem walk");
+        logger2.info({ repoPath }, "Not a git repository, using filesystem walk");
         return null;
       }
       const { stdout } = await execFileAsync("git", ["ls-files", "-z"], {
@@ -3300,12 +4023,12 @@ var IndexService = class {
       });
       const files = stdout.split("\0").filter(Boolean);
       if (files.some((f) => f === ".gitmodules")) {
-        logger.info({ repoPath }, "Repository has submodules (skipped by ls-files)");
+        logger2.info({ repoPath }, "Repository has submodules (skipped by ls-files)");
       }
       return files;
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
-      logger.warn({ repoPath, reason }, "git ls-files failed, using filesystem walk");
+      logger2.warn({ repoPath, reason }, "git ls-files failed, using filesystem walk");
       return null;
     }
   }
@@ -3318,11 +4041,11 @@ var IndexService = class {
     const trackedFiles = await this.getTrackedFiles(storePath);
     let candidates;
     if (trackedFiles !== null) {
-      candidates = trackedFiles.map((f) => join7(storePath, f));
-      logger.debug({ storePath, count: candidates.length }, "Using git ls-files for discovery");
+      candidates = trackedFiles.map((f) => join8(storePath, f));
+      logger2.debug({ storePath, count: candidates.length }, "Using git ls-files for discovery");
     } else {
       candidates = await this.scanDirectory(storePath);
-      logger.debug({ storePath, count: candidates.length }, "Using filesystem walk for discovery");
+      logger2.debug({ storePath, count: candidates.length }, "Using filesystem walk for discovery");
     }
     return this.filterFiles(candidates, storePath, ingestConfig);
   }
@@ -3344,6 +4067,12 @@ var IndexService = class {
       const ext = extname(filePath).toLowerCase();
       const filename = basename(filePath);
       if (!TEXT_EXTENSIONS.has(ext)) continue;
+      const relativePath = relative(storePath, filePath).replaceAll("\\", "/");
+      const pathSegments = relativePath.split("/");
+      const dirSegments = pathSegments.slice(0, -1);
+      if (dirSegments.some((segment) => this.ignoreDirs.has(segment))) {
+        continue;
+      }
       const shouldIgnore = this.ignoreFilePatterns.some((matcher) => matcher(filename));
       if (shouldIgnore) continue;
       if (skipMinified && isMinifiedFile(filename)) {
@@ -3351,10 +4080,10 @@ var IndexService = class {
         continue;
       }
       if (excludeGlobs.length > 0) {
-        const relativePath = relative(storePath, filePath);
-        const excluded = excludeGlobs.some((glob) => minimatch(relativePath, glob));
+        const relativePath2 = relative(storePath, filePath);
+        const excluded = excludeGlobs.some((glob) => minimatch(relativePath2, glob));
         if (excluded) {
-          skippedExcluded.push(relativePath);
+          skippedExcluded.push(relativePath2);
           continue;
         }
       }
@@ -3382,7 +4111,7 @@ var IndexService = class {
       result.push(filePath);
     }
     if (skippedLarge.length > 0) {
-      logger.info(
+      logger2.info(
         {
           storePath,
           count: skippedLarge.length,
@@ -3393,19 +4122,19 @@ var IndexService = class {
       );
     }
     if (skippedMinified.length > 0) {
-      logger.debug(
+      logger2.debug(
         { storePath, count: skippedMinified.length, examples: skippedMinified.slice(0, 5) },
         "Skipped minified files"
       );
     }
     if (skippedBinary.length > 0) {
-      logger.debug(
+      logger2.debug(
         { storePath, count: skippedBinary.length, examples: skippedBinary.slice(0, 5) },
         "Skipped binary files"
       );
     }
     if (skippedExcluded.length > 0) {
-      logger.debug(
+      logger2.debug(
         { storePath, count: skippedExcluded.length, examples: skippedExcluded.slice(0, 5) },
         "Skipped excluded files"
       );
@@ -3416,7 +4145,7 @@ var IndexService = class {
     const files = [];
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join7(dir, entry.name);
+      const fullPath = join8(dir, entry.name);
       if (entry.isDirectory()) {
         if (!this.ignoreDirs.has(entry.name)) {
           files.push(...await this.scanDirectory(fullPath));
@@ -3517,7 +4246,7 @@ function classifyWebContentType(url, title) {
 
 // src/services/manifest.service.ts
 import { readFile as readFile6, access as access3, mkdir as mkdir3 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/types/manifest.ts
 import { z as z2 } from "zod";
@@ -3554,7 +4283,7 @@ function createEmptyManifest(storeId) {
 var ManifestService = class {
   manifestsDir;
   constructor(dataDir) {
-    this.manifestsDir = join8(dataDir, "manifests");
+    this.manifestsDir = join9(dataDir, "manifests");
   }
   /**
    * Initialize the manifests directory.
@@ -3566,7 +4295,7 @@ var ManifestService = class {
    * Get the file path for a store's manifest.
    */
   getManifestPath(storeId) {
-    return join8(this.manifestsDir, `${storeId}.manifest.json`);
+    return join9(this.manifestsDir, `${storeId}.manifest.json`);
   }
   /**
    * Load a store's manifest.
@@ -3650,6 +4379,202 @@ var ManifestService = class {
   }
 };
 
+// src/services/reranker.service.ts
+import { homedir as homedir3 } from "os";
+import { join as join10 } from "path";
+import { env as env2, AutoModelForSequenceClassification, AutoTokenizer } from "@huggingface/transformers";
+env2.cacheDir = join10(homedir3(), ".cache", "huggingface-transformers");
+var DEBUG_RERANKER = process.env["BK_DEBUG_RERANKER"] === "1";
+var debugStats = {
+  totalQueries: 0,
+  top1Reordered: 0,
+  top3Reordered: 0,
+  scoreVariancePositive: 0
+};
+if (DEBUG_RERANKER) {
+  process.on("beforeExit", () => {
+    RerankerService.logDebugStats();
+  });
+}
+var RerankerService = class {
+  model = null;
+  tokenizer = null;
+  initPromise = null;
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly -- mutated in dispose()
+  disposed = false;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Guard against use-after-dispose
+   */
+  assertNotDisposed() {
+    if (this.disposed) {
+      throw new Error("RerankerService has been disposed");
+    }
+  }
+  /**
+   * Check if reranking is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Initialize the reranker model (concurrency-safe).
+   * Multiple concurrent calls will share the same initialization promise.
+   */
+  async initialize() {
+    this.assertNotDisposed();
+    if (this.model !== null && this.tokenizer !== null) return;
+    this.initPromise ??= (async () => {
+      try {
+        const [model, tokenizer] = await Promise.all([
+          AutoModelForSequenceClassification.from_pretrained(this.config.model, {
+            dtype: "fp32"
+          }),
+          AutoTokenizer.from_pretrained(this.config.model)
+        ]);
+        this.model = model;
+        this.tokenizer = tokenizer;
+      } catch (error) {
+        this.initPromise = null;
+        throw error;
+      }
+    })();
+    await this.initPromise;
+  }
+  /**
+   * Rerank candidates by scoring query-document pairs with the cross-encoder.
+   * Returns results sorted by reranker score (descending).
+   */
+  async rerank(query, candidates) {
+    this.assertNotDisposed();
+    const startTime = Date.now();
+    if (!this.config.enabled) {
+      return {
+        results: candidates.map((c) => ({
+          id: c.id,
+          originalScore: c.score,
+          rerankerScore: c.score
+        })),
+        timeMs: Date.now() - startTime
+      };
+    }
+    if (candidates.length === 0) {
+      return { results: [], timeMs: Date.now() - startTime };
+    }
+    if (this.model === null || this.tokenizer === null) {
+      await this.initialize();
+    }
+    if (this.model === null || this.tokenizer === null) {
+      throw new Error("Failed to initialize reranker model");
+    }
+    const toRerank = candidates.slice(0, this.config.topK);
+    const scoredResults = [];
+    for (const candidate of toRerank) {
+      const score = await this.scoreQueryDocPair(query, candidate.content);
+      scoredResults.push({
+        id: candidate.id,
+        originalScore: candidate.score,
+        rerankerScore: score
+      });
+    }
+    const preRankIds = scoredResults.map((r) => r.id);
+    scoredResults.sort((a, b) => b.rerankerScore - a.rerankerScore);
+    if (DEBUG_RERANKER) {
+      const postRankIds = scoredResults.map((r) => r.id);
+      debugStats.totalQueries++;
+      if (preRankIds[0] !== postRankIds[0]) debugStats.top1Reordered++;
+      const preTop3 = preRankIds.slice(0, 3).join(",");
+      const postTop3 = postRankIds.slice(0, 3).join(",");
+      if (preTop3 !== postTop3) debugStats.top3Reordered++;
+      const scores = scoredResults.map((r) => r.rerankerScore);
+      const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
+      const variance = scores.reduce((a, b) => a + (b - mean) ** 2, 0) / scores.length;
+      if (variance > 1e-10) debugStats.scoreVariancePositive++;
+      if (debugStats.totalQueries <= 3) {
+        console.error(
+          `[DEBUG_RERANKER] query #${String(debugStats.totalQueries)}: pre=[${preRankIds.slice(0, 3).join(", ")}] post=[${postRankIds.slice(0, 3).join(", ")}] scores=[${scores.slice(0, 3).map((s) => s.toFixed(4)).join(", ")}] variance=${variance.toFixed(6)}`
+        );
+      }
+    }
+    const finalResults = scoredResults.slice(0, this.config.returnK);
+    return {
+      results: finalResults,
+      timeMs: Date.now() - startTime
+    };
+  }
+  /**
+   * Score a single query-document pair using the cross-encoder.
+   */
+  async scoreQueryDocPair(query, document) {
+    if (this.model === null || this.tokenizer === null) {
+      throw new Error("Model not initialized");
+    }
+    const inputs = await this.tokenizer([query], {
+      text_pair: [document],
+      padding: true,
+      truncation: true,
+      max_length: 512
+    });
+    const output = await this.model(inputs);
+    const logits = output.logits;
+    const scores = Array.from(logits.data);
+    const score = scores[0];
+    if (typeof score !== "number") {
+      throw new Error("Invalid reranker output: expected numeric score");
+    }
+    return score;
+  }
+  /**
+   * Check if the reranker is initialized.
+   */
+  isInitialized() {
+    return this.model !== null && this.tokenizer !== null;
+  }
+  /**
+   * Check if this service has been disposed.
+   */
+  isDisposed() {
+    return this.disposed;
+  }
+  /**
+   * Reset the service to uninitialized state, allowing reuse after disposal.
+   */
+  async reset() {
+    if (this.model !== null) {
+      await this.model.dispose();
+      this.model = null;
+    }
+    this.tokenizer = null;
+    this.initPromise = null;
+    this.disposed = false;
+  }
+  /**
+   * Log aggregate reranker debug stats. Only meaningful when BK_DEBUG_RERANKER=1.
+   */
+  static logDebugStats() {
+    if (!DEBUG_RERANKER || debugStats.totalQueries === 0) return;
+    const pct = (n) => (n / debugStats.totalQueries * 100).toFixed(1);
+    console.error(
+      `[DEBUG_RERANKER] Aggregate: ${String(debugStats.totalQueries)} queries, top1 reordered: ${pct(debugStats.top1Reordered)}% (${String(debugStats.top1Reordered)}/${String(debugStats.totalQueries)}), top3 reordered: ${pct(debugStats.top3Reordered)}% (${String(debugStats.top3Reordered)}/${String(debugStats.totalQueries)}), score variance>0: ${pct(debugStats.scoreVariancePositive)}% (${String(debugStats.scoreVariancePositive)}/${String(debugStats.totalQueries)})`
+    );
+  }
+  /**
+   * Dispose the reranker to free resources.
+   */
+  async dispose() {
+    if (this.model !== null) {
+      await this.model.dispose();
+      this.model = null;
+    }
+    this.tokenizer = null;
+    this.initPromise = null;
+    this.disposed = true;
+  }
+};
+
 // src/services/code-unit.service.ts
 var CodeUnitService = class {
   extractCodeUnit(code, symbolName, language) {
@@ -3819,8 +4744,51 @@ var CodeUnitService = class {
   }
 };
 
+// src/services/search-env.ts
+var logger3 = createLogger("search-env");
+function parseSearchEnvOverrides(strict) {
+  return {
+    rrfK: parseRrfK(process.env["BK_RRF_K"], strict),
+    vectorWeight: parseVectorWeight(process.env["BK_RRF_VECTOR_WEIGHT"], strict),
+    candidateMultiplier: parseCandidateMultiplier(process.env["BK_CANDIDATE_MULTIPLIER"], strict)
+  };
+}
+function parseRrfK(raw, strict) {
+  if (raw === void 0 || raw === "") return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isNaN(parsed) || parsed <= 0) {
+    const msg = `BK_RRF_K must be a positive integer, got: "${raw}"`;
+    if (strict) throw new Error(msg);
+    logger3.warn(msg);
+    return void 0;
+  }
+  return parsed;
+}
+function parseVectorWeight(raw, strict) {
+  if (raw === void 0 || raw === "") return void 0;
+  const parsed = Number.parseFloat(raw);
+  if (Number.isNaN(parsed) || parsed < 0 || parsed > 1) {
+    const msg = `BK_RRF_VECTOR_WEIGHT must be a float between 0 and 1, got: "${raw}"`;
+    if (strict) throw new Error(msg);
+    logger3.warn(msg);
+    return void 0;
+  }
+  return parsed;
+}
+function parseCandidateMultiplier(raw, strict) {
+  if (raw === void 0 || raw === "") return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isNaN(parsed) || parsed < 1) {
+    const msg = `BK_CANDIDATE_MULTIPLIER must be an integer >= 1, got: "${raw}"`;
+    if (strict) throw new Error(msg);
+    logger3.warn(msg);
+    return void 0;
+  }
+  return parsed;
+}
+
 // src/services/search.service.ts
-var logger2 = createLogger("search-service");
+var logger4 = createLogger("search-service");
 var INTENT_FILE_BOOSTS = {
   "how-to": {
     "documentation-primary": 1.3,
@@ -3982,9 +4950,10 @@ function mapSearchIntentToQueryIntent(intent) {
   }
 }
 var RRF_PRESETS = {
-  code: { k: 20, vectorWeight: 0.6, ftsWeight: 0.4 },
-  web: { k: 30, vectorWeight: 0.55, ftsWeight: 0.45 }
+  code: { k: 25, vectorWeight: 0.75, ftsWeight: 0.25 },
+  web: { k: 30, vectorWeight: 0.7, ftsWeight: 0.3 }
 };
+var DEFAULT_CANDIDATE_MULTIPLIER = 2;
 function detectContentType(results) {
   const webCount = results.filter((r) => "url" in r.metadata).length;
   return webCount > results.length / 2 ? "web" : "code";
@@ -3993,13 +4962,15 @@ var SearchService = class {
   lanceStore;
   codeUnitService;
   codeGraphService;
+  rerankerService;
   graphCache;
   searchConfig;
   unsubscribeCacheInvalidation;
-  constructor(lanceStore, codeGraphService, searchConfig) {
+  constructor(lanceStore, codeGraphService, searchConfig, rerankerService) {
     this.lanceStore = lanceStore;
     this.codeUnitService = new CodeUnitService();
     this.codeGraphService = codeGraphService;
+    this.rerankerService = rerankerService;
     this.graphCache = /* @__PURE__ */ new Map();
     this.searchConfig = searchConfig;
     if (codeGraphService) {
@@ -4047,7 +5018,7 @@ var SearchService = class {
     const detail = query.detail ?? "minimal";
     const intents = classifyQueryIntents(query.query);
     const primaryIntent = query.intent !== void 0 ? mapSearchIntentToQueryIntent(query.intent) : getPrimaryIntent(intents);
-    logger2.debug(
+    logger4.debug(
       {
         query: query.query,
         mode,
@@ -4063,6 +5034,7 @@ var SearchService = class {
     );
     let allResults = [];
     let maxRawScore = 0;
+    let rerankTimeMs;
     const fetchLimit = limit * 3;
     if (mode === "vector") {
       const rawResults = await this.vectorSearchRaw(query.query, stores, fetchLimit);
@@ -4079,16 +5051,17 @@ var SearchService = class {
       );
       allResults = hybridResult.results;
       maxRawScore = hybridResult.maxRawScore;
+      rerankTimeMs = hybridResult.rerankTimeMs;
     }
     if (query.minRelevance !== void 0) {
       if (mode === "fts") {
-        logger2.warn(
+        logger4.warn(
           { query: query.query, minRelevance: query.minRelevance },
           "minRelevance filter ignored in FTS mode (no vector scores available)"
         );
       } else if (maxRawScore < query.minRelevance) {
         const timeMs2 = Date.now() - startTime;
-        logger2.info(
+        logger4.info(
           {
             query: query.query,
             mode,
@@ -4125,7 +5098,7 @@ var SearchService = class {
     });
     const timeMs = Date.now() - startTime;
     const confidence = mode !== "fts" ? this.calculateConfidence(maxRawScore) : void 0;
-    logger2.info(
+    logger4.info(
       {
         query: query.query,
         mode,
@@ -4138,7 +5111,7 @@ var SearchService = class {
       },
       "Search complete"
     );
-    return {
+    const response = {
       query: query.query,
       mode,
       stores,
@@ -4148,6 +5121,10 @@ var SearchService = class {
       confidence,
       maxRawScore: mode !== "fts" ? maxRawScore : void 0
     };
+    if (rerankTimeMs !== void 0) {
+      Object.assign(response, { rerankTimeMs });
+    }
+    return response;
   }
   /**
    * Deduplicate results by source file path.
@@ -4253,14 +5230,16 @@ var SearchService = class {
    */
   async hybridSearchWithMetadata(query, stores, limit, threshold) {
     const intents = classifyQueryIntents(query);
-    const rawVectorResults = await this.vectorSearchRaw(query, stores, limit * 2);
+    const envOverrides = parseSearchEnvOverrides(false);
+    const candidateMultiplier = envOverrides.candidateMultiplier ?? DEFAULT_CANDIDATE_MULTIPLIER;
+    const rawVectorResults = await this.vectorSearchRaw(query, stores, limit * candidateMultiplier);
     const rawVectorScores = /* @__PURE__ */ new Map();
     rawVectorResults.forEach((r) => {
       rawVectorScores.set(r.id, r.score);
     });
     const maxRawScore = rawVectorResults.length > 0 ? rawVectorResults[0]?.score ?? 0 : 0;
     const vectorResults = this.normalizeAndFilterScores(rawVectorResults);
-    const ftsResults = await this.ftsSearch(query, stores, limit * 2);
+    const ftsResults = await this.ftsSearch(query, stores, limit * candidateMultiplier);
     const vectorRanks = /* @__PURE__ */ new Map();
     const ftsRanks = /* @__PURE__ */ new Map();
     const allDocs = /* @__PURE__ */ new Map();
@@ -4276,8 +5255,11 @@ var SearchService = class {
     });
     const rrfScores = [];
     const contentType = detectContentType([...allDocs.values()]);
-    const { k, vectorWeight, ftsWeight } = RRF_PRESETS[contentType];
-    for (const [id, result] of allDocs) {
+    const preset = RRF_PRESETS[contentType];
+    const k = envOverrides.rrfK ?? preset.k;
+    const vectorWeight = envOverrides.vectorWeight ?? preset.vectorWeight;
+    const ftsWeight = 1 - vectorWeight;
+    for (const [id, result2] of allDocs) {
       const vectorRank = vectorRanks.get(id) ?? Infinity;
       const ftsRank = ftsRanks.get(id) ?? Infinity;
       const rawVectorScore = rawVectorScores.get(id);
@@ -4285,19 +5267,23 @@ var SearchService = class {
       const ftsRRF = ftsRank !== Infinity ? ftsWeight / (k + ftsRank) : 0;
       const fileTypeBoost = this.getFileTypeBoost(
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        result.metadata["fileType"],
+        result2.metadata["fileType"],
         intents
       );
-      const frameworkBoost = this.getFrameworkContextBoost(query, result);
-      const urlKeywordBoost = this.getUrlKeywordBoost(query, result);
-      const pathKeywordBoost = this.getPathKeywordBoost(query, result);
+      const frameworkBoost = this.getFrameworkContextBoost(query, result2);
+      const urlKeywordBoost = this.getUrlKeywordBoost(query, result2);
+      const pathKeywordBoost = this.getPathKeywordBoost(query, result2);
+      const depthBoost = this.getDepthBoost(result2, getPrimaryIntent(intents));
+      const entryPointBoost = this.getEntryPointBoost(result2, getPrimaryIntent(intents));
       const metadata = {
         vectorRRF,
         ftsRRF,
         fileTypeBoost,
         frameworkBoost,
         urlKeywordBoost,
-        pathKeywordBoost
+        pathKeywordBoost,
+        depthBoost,
+        entryPointBoost
       };
       if (vectorRank !== Infinity) {
         metadata.vectorRank = vectorRank;
@@ -4310,13 +5296,34 @@ var SearchService = class {
       }
       rrfScores.push({
         id,
-        score: (vectorRRF + ftsRRF) * fileTypeBoost * frameworkBoost * urlKeywordBoost * pathKeywordBoost,
-        result,
+        score: (vectorRRF + ftsRRF) * fileTypeBoost * frameworkBoost * urlKeywordBoost * pathKeywordBoost * depthBoost * entryPointBoost,
+        result: result2,
         rawVectorScore,
         metadata
       });
     }
-    const sorted = rrfScores.sort((a, b) => b.score - a.score).slice(0, limit);
+    const sortedAll = rrfScores.sort((a, b) => b.score - a.score);
+    let rerankTimeMs;
+    let sorted;
+    if (this.rerankerService !== void 0 && this.rerankerService.isEnabled() && sortedAll.length > 0) {
+      const candidates = sortedAll.map((r) => ({
+        id: r.id,
+        content: r.result.content,
+        score: r.score
+      }));
+      const reranked = await this.rerankerService.rerank(query, candidates);
+      rerankTimeMs = reranked.timeMs;
+      const rerankedScores = /* @__PURE__ */ new Map();
+      reranked.results.forEach((r) => {
+        rerankedScores.set(r.id, r.rerankerScore);
+      });
+      sorted = sortedAll.map((r) => ({
+        ...r,
+        rerankerScore: rerankedScores.get(r.id)
+      })).sort((a, b) => (b.rerankerScore ?? -Infinity) - (a.rerankerScore ?? -Infinity)).slice(0, limit);
+    } else {
+      sorted = sortedAll.slice(0, limit);
+    }
     let normalizedResults;
     if (sorted.length > 0) {
       const first = sorted[0];
@@ -4351,7 +5358,14 @@ var SearchService = class {
     if (threshold !== void 0) {
       normalizedResults = normalizedResults.filter((r) => r.score >= threshold);
     }
-    return { results: normalizedResults, maxRawScore };
+    const result = {
+      results: normalizedResults,
+      maxRawScore
+    };
+    if (rerankTimeMs !== void 0) {
+      result.rerankTimeMs = rerankTimeMs;
+    }
+    return result;
   }
   async searchAllStores(query, storeIds) {
     return this.search({
@@ -4500,6 +5514,33 @@ var SearchService = class {
     const matchRatio = matchingTerms.length / queryTerms.length;
     return 1 + 1 * matchRatio;
   }
+  /**
+   * Get a depth-based score multiplier, gated by query intent.
+   * Root-level files (depth 0) are boosted for how-to and conceptual queries
+   * where high-level docs/READMEs are most relevant.
+   * Returns 1.0 (no-op) for implementation/debugging/comparison intents
+   * to avoid disturbing candidate ordering before reranker.
+   */
+  getDepthBoost(result, intent) {
+    if (intent !== "how-to" && intent !== "conceptual") return 1;
+    const depth = result.metadata["depth"];
+    if (typeof depth !== "number") return 1;
+    if (depth === 0) return 1.08;
+    if (depth === 1) return 1.04;
+    return 1;
+  }
+  /**
+   * Get an entry-point score multiplier, gated by query intent.
+   * Entry-point files (index.ts, main.py, etc.) are boosted for how-to
+   * and implementation queries where API surfaces are most relevant.
+   * Returns 1.0 (no-op) for debugging/comparison/conceptual intents.
+   */
+  getEntryPointBoost(result, intent) {
+    if (intent !== "how-to" && intent !== "implementation") return 1;
+    const isEntryPoint = result.metadata["isEntryPoint"];
+    if (isEntryPoint !== true) return 1;
+    return 1.08;
+  }
   /**
    * Get a score multiplier based on framework context.
    * If query mentions a framework, boost results from that framework's files.
@@ -4798,7 +5839,7 @@ var SearchService = class {
 
 // src/services/store-definition.service.ts
 import { readFile as readFile7, access as access4 } from "fs/promises";
-import { resolve as resolve2, isAbsolute as isAbsolute2, join as join9 } from "path";
+import { resolve as resolve2, isAbsolute as isAbsolute2, join as join11 } from "path";
 
 // src/types/store-definition.ts
 import { z as z3 } from "zod";
@@ -4889,7 +5930,7 @@ var StoreDefinitionService = class {
   config = null;
   constructor(projectRoot) {
     this.projectRoot = projectRoot ?? ProjectRootService.resolve();
-    this.configPath = join9(this.projectRoot, ".bluera/bluera-knowledge/stores.config.json");
+    this.configPath = join11(this.projectRoot, ".bluera/bluera-knowledge/stores.config.json");
   }
   /**
    * Load store definitions from config file.
@@ -5028,12 +6069,12 @@ var StoreDefinitionService = class {
 // src/services/store.service.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { readFile as readFile8, mkdir as mkdir5, stat as stat3, access as access5 } from "fs/promises";
-import { join as join10, resolve as resolve3, relative as relative2, isAbsolute as isAbsolute3 } from "path";
+import { join as join12, resolve as resolve3, relative as relative2, isAbsolute as isAbsolute3 } from "path";
 
 // src/plugin/git-clone.ts
 import { spawn } from "child_process";
 import { mkdir as mkdir4 } from "fs/promises";
-var logger3 = createLogger("git-clone");
+var logger5 = createLogger("git-clone");
 function sanitizeUrl(url) {
   try {
     const parsed = new URL(url);
@@ -5065,7 +6106,7 @@ async function cloneRepository(options) {
     args.push("--branch", branch);
   }
   args.push(url, targetDir);
-  logger3.info(
+  logger5.info(
     {
       url: sanitizeUrl(url),
       targetDir,
@@ -5102,7 +6143,7 @@ async function cloneRepository(options) {
       clearTimeout(timeout);
       if (forceKillTimeout) clearTimeout(forceKillTimeout);
       if (timedOut) {
-        resolve4(err(new Error(`Git clone timed out after ${String(timeoutMs)}ms`)));
+        resolve4(err(new Error(`Git clone timed out after ${String(timeoutMs)}ms for: ${url}`)));
       } else if (code === 0) {
         resolve4(ok(targetDir));
       } else {
@@ -5127,7 +6168,7 @@ function extractRepoName(url) {
 var CURRENT_SCHEMA_VERSION = 3;
 
 // src/services/store.service.ts
-var logger4 = createLogger("store-service");
+var logger6 = createLogger("store-service");
 async function fileExists4(path4) {
   try {
     await access5(path4);
@@ -5176,10 +6217,10 @@ var StoreService = class {
     }
     const relativePath = relative2(this.projectRoot, absolutePath);
     if (relativePath.startsWith("..") || isAbsolute3(relativePath)) {
-      logger4.info(`Path outside projectRoot, storing absolute: ${absolutePath}`);
+      logger6.info(`Path outside projectRoot, storing absolute: ${absolutePath}`);
       return { path: absolutePath, pathType: "absolute" };
     }
-    logger4.debug(`Storing relative path: ${relativePath} (resolved from ${absolutePath})`);
+    logger6.debug(`Storing relative path: ${relativePath} (resolved from ${absolutePath})`);
     return { path: relativePath, pathType: "relative" };
   }
   /**
@@ -5194,11 +6235,11 @@ var StoreService = class {
       return storedPath;
     }
     if (this.projectRoot === void 0) {
-      logger4.error(`Store has relative path but no projectRoot: ${storedPath}`);
+      logger6.error(`Store has relative path but no projectRoot: ${storedPath}`);
       return storedPath;
     }
     const resolved = resolve3(this.projectRoot, storedPath);
-    logger4.debug(`Resolved relative path: ${storedPath} \u2192 ${resolved}`);
+    logger6.debug(`Resolved relative path: ${storedPath} \u2192 ${resolved}`);
     return resolved;
   }
   async initialize() {
@@ -5210,7 +6251,7 @@ var StoreService = class {
    * This enables MCP server to see stores created by CLI without restart.
    */
   async ensureRegistryFresh() {
-    const registryPath = join10(this.dataDir, "stores.json");
+    const registryPath = join12(this.dataDir, "stores.json");
     try {
       const stats = await stat3(registryPath);
       if (stats.mtimeMs > this.registryMtime) {
@@ -5366,7 +6407,7 @@ var StoreService = class {
       case "repo": {
         let repoPath = input.path;
         if (input.url !== void 0) {
-          const cloneDir = join10(this.dataDir, "repos", id);
+          const cloneDir = join12(this.dataDir, "repos", id);
           const result = await cloneRepository({
             url: input.url,
             targetDir: cloneDir,
@@ -5567,7 +6608,7 @@ var StoreService = class {
     await this.saveRegistry();
   }
   async loadRegistry() {
-    const registryPath = join10(this.dataDir, "stores.json");
+    const registryPath = join12(this.dataDir, "stores.json");
     const exists = await fileExists4(registryPath);
     if (!exists) {
       this.registry = { stores: [] };
@@ -5602,7 +6643,7 @@ var StoreService = class {
         })
       };
       if (migrationNeeded) {
-        logger4.debug("Schema migration needed - will upgrade on next save");
+        logger6.debug("Schema migration needed - will upgrade on next save");
         this.needsMigration = true;
       }
     } catch (error) {
@@ -5614,7 +6655,7 @@ var StoreService = class {
     this.registryMtime = loadedStats.mtimeMs;
   }
   async saveRegistry() {
-    const registryPath = join10(this.dataDir, "stores.json");
+    const registryPath = join12(this.dataDir, "stores.json");
     const storedStores = this.registry.stores.map((store) => {
       const schemaVersion = this.needsMigration ? CURRENT_SCHEMA_VERSION : store.schemaVersion;
       if (store.type === "file") {
@@ -5642,7 +6683,7 @@ var StoreService = class {
       }
     });
     if (this.needsMigration) {
-      logger4.info("Schema migration complete - upgraded to v3");
+      logger6.info("Schema migration complete - upgraded to v3");
       this.needsMigration = false;
     }
     await atomicWriteFile(registryPath, JSON.stringify({ stores: storedStores }, null, 2));
@@ -5693,7 +6734,7 @@ function validateParsePythonResult(data) {
 }
 
 // src/crawl/bridge.ts
-var logger5 = createLogger("python-bridge");
+var logger7 = createLogger("python-bridge");
 function getPythonExecutable() {
   return process.platform === "win32" ? "python" : "python3";
 }
@@ -5728,7 +6769,7 @@ var PythonBridge = class {
       pythonWorkerPath = path3.join(projectRoot, "python", "ast_worker.py");
       pythonPath = getPythonExecutable();
     }
-    logger5.debug(
+    logger7.debug(
       { pythonWorkerPath, pythonPath, currentFilePath, isProduction },
       "Starting Python bridge process"
     );
@@ -5736,15 +6777,15 @@ var PythonBridge = class {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.process.on("error", (err2) => {
-      logger5.error({ error: err2.message, stack: err2.stack }, "Python bridge process error");
+      logger7.error({ error: err2.message, stack: err2.stack }, "Python bridge process error");
       this.rejectAllPending(new Error(`Process error: ${err2.message}`));
     });
     this.process.on("exit", (code, signal) => {
       if (code !== 0 && code !== null) {
-        logger5.error({ code }, "Python bridge process exited with non-zero code");
+        logger7.error({ code }, "Python bridge process exited with non-zero code");
         this.rejectAllPending(new Error(`Process exited with code ${String(code)}`));
       } else if (signal && !this.stoppingIntentionally) {
-        logger5.error({ signal }, "Python bridge process killed with signal");
+        logger7.error({ signal }, "Python bridge process killed with signal");
         this.rejectAllPending(new Error(`Process killed with signal ${signal}`));
       }
       this.process = null;
@@ -5753,7 +6794,7 @@ var PythonBridge = class {
     if (this.process.stderr) {
       this.stderrReadline = createInterface({ input: this.process.stderr });
       this.stderrReadline.on("line", (line) => {
-        logger5.warn({ stderr: line }, "Python bridge stderr output");
+        logger7.warn({ stderr: line }, "Python bridge stderr output");
       });
     }
     if (this.process.stdout === null) {
@@ -5782,7 +6823,7 @@ var PythonBridge = class {
               pending.resolve(validated);
             } catch (error) {
               if (error instanceof ZodError) {
-                logger5.error(
+                logger7.error(
                   {
                     issues: error.issues,
                     response: JSON.stringify(response.result)
@@ -5794,14 +6835,14 @@ var PythonBridge = class {
                 );
               } else {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                logger5.error({ error: errorMessage }, "Response validation error");
+                logger7.error({ error: errorMessage }, "Response validation error");
                 pending.reject(new Error(`Response validation error: ${errorMessage}`));
               }
             }
           }
         }
       } catch (err2) {
-        logger5.error(
+        logger7.error(
           {
             error: err2 instanceof Error ? err2.message : String(err2),
             line
@@ -5897,242 +6938,9 @@ var PythonBridge = class {
   }
 };
 
-// src/db/embeddings.ts
-import { homedir as homedir2 } from "os";
-import { join as join11 } from "path";
-import { pipeline, env } from "@huggingface/transformers";
-env.cacheDir = join11(homedir2(), ".cache", "huggingface-transformers");
-var DEFAULT_EMBEDDING_CONFIG = {
-  model: "Xenova/bge-small-en-v1.5",
-  batchSize: 32,
-  dtype: "fp32",
-  pooling: "mean",
-  normalize: true,
-  queryPrefix: "Represent this sentence for searching relevant passages: ",
-  docPrefix: "",
-  maxInFlightBatches: 1
-};
-var EmbeddingEngine = class {
-  extractor = null;
-  initPromise = null;
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly -- mutated in embed() and embedBatch()
-  _dimensions = null;
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly -- mutated in dispose()
-  disposed = false;
-  config;
-  constructor(config = DEFAULT_EMBEDDING_CONFIG) {
-    this.config = config;
-  }
-  /**
-   * Guard against use-after-dispose
-   */
-  assertNotDisposed() {
-    if (this.disposed) {
-      throw new Error("EmbeddingEngine has been disposed");
-    }
-  }
-  /**
-   * Initialize the embedding pipeline (concurrency-safe).
-   * Multiple concurrent calls will share the same initialization promise.
-   */
-  async initialize() {
-    this.assertNotDisposed();
-    if (this.extractor !== null) return;
-    this.initPromise ??= (async () => {
-      try {
-        this.extractor = await pipeline("feature-extraction", this.config.model, {
-          dtype: this.config.dtype
-        });
-      } catch (error) {
-        this.initPromise = null;
-        throw error;
-      }
-    })();
-    await this.initPromise;
-  }
-  /**
-   * Embed a search query. Applies queryPrefix for asymmetric models.
-   */
-  async embedQuery(text) {
-    return this.embedText(this.config.queryPrefix + text);
-  }
-  /**
-   * Embed a document for indexing. Applies docPrefix for asymmetric models.
-   */
-  async embedDocument(text) {
-    return this.embedText(this.config.docPrefix + text);
-  }
-  /**
-   * Internal: embed text without prefix.
-   */
-  async embedText(text) {
-    this.assertNotDisposed();
-    if (this.extractor === null) {
-      await this.initialize();
-    }
-    if (this.extractor === null) {
-      throw new Error("Failed to initialize embedding model");
-    }
-    const output = await this.extractor(text, {
-      pooling: this.config.pooling,
-      normalize: this.config.normalize
-    });
-    const dim = output.dims[output.dims.length - 1] ?? 0;
-    this._dimensions ??= dim;
-    return Float32Array.from(output.data);
-  }
-  /**
-   * Embed a batch of documents with optional parallelism.
-   * When maxInFlightBatches > 1, processes multiple batches concurrently.
-   */
-  async embedBatch(texts) {
-    this.assertNotDisposed();
-    if (this.extractor === null) {
-      await this.initialize();
-    }
-    if (this.extractor === null) {
-      throw new Error("Failed to initialize embedding model");
-    }
-    const batches = [];
-    for (let i = 0; i < texts.length; i += this.config.batchSize) {
-      batches.push(texts.slice(i, i + this.config.batchSize));
-    }
-    if (batches.length === 0) {
-      return [];
-    }
-    if (this.config.maxInFlightBatches <= 1) {
-      return this.embedBatchesSequential(batches);
-    } else {
-      return this.embedBatchesConcurrent(batches);
-    }
-  }
-  /**
-   * Process batches sequentially (original behavior).
-   */
-  async embedBatchesSequential(batches) {
-    const results = [];
-    for (let i = 0; i < batches.length; i++) {
-      const batch = batches[i];
-      if (batch === void 0) continue;
-      const batchResults = await this.processSingleBatch(batch);
-      results.push(...batchResults);
-      if (i < batches.length - 1) {
-        await new Promise((resolve4) => setImmediate(resolve4));
-      }
-    }
-    return results;
-  }
-  /**
-   * Process batches with controlled concurrency.
-   */
-  async embedBatchesConcurrent(batches) {
-    const results = new Array(batches.length);
-    let inFlight = 0;
-    const maxConcurrent = this.config.maxInFlightBatches;
-    await Promise.all(
-      batches.map(async (batch, idx) => {
-        while (inFlight >= maxConcurrent) {
-          await new Promise((resolve4) => setImmediate(resolve4));
-        }
-        inFlight++;
-        try {
-          results[idx] = await this.processSingleBatch(batch);
-        } finally {
-          inFlight--;
-        }
-      })
-    );
-    return results.flat();
-  }
-  /**
-   * Process a single batch and return embeddings.
-   */
-  async processSingleBatch(batch) {
-    if (this.extractor === null) {
-      throw new Error("Extractor not initialized");
-    }
-    const prefixedBatch = batch.map((text) => this.config.docPrefix + text);
-    const output = await this.extractor(prefixedBatch, {
-      pooling: this.config.pooling,
-      normalize: this.config.normalize
-    });
-    const dim = output.dims[output.dims.length - 1] ?? 0;
-    const batchResults = [];
-    for (let b = 0; b < batch.length; b++) {
-      const start = b * dim;
-      const end = start + dim;
-      batchResults.push(Float32Array.from(output.data.slice(start, end)));
-    }
-    this._dimensions ??= dim;
-    return batchResults;
-  }
-  /**
-   * Get cached embedding dimensions. Throws if embed() hasn't been called yet.
-   * Use ensureDimensions() if you need to guarantee dimensions are available.
-   */
-  getDimensions() {
-    if (this._dimensions === null) {
-      throw new Error("Cannot get dimensions before first embed() call");
-    }
-    return this._dimensions;
-  }
-  /**
-   * Check if the embedding pipeline is initialized.
-   */
-  isInitialized() {
-    return this.extractor !== null;
-  }
-  /**
-   * Check if this engine has been disposed.
-   */
-  isDisposed() {
-    return this.disposed;
-  }
-  /**
-   * Reset the engine to uninitialized state, allowing reuse after disposal.
-   * If currently initialized, disposes the pipeline first.
-   */
-  async reset() {
-    if (this.extractor !== null) {
-      await this.extractor.dispose();
-      this.extractor = null;
-    }
-    this.initPromise = null;
-    this._dimensions = null;
-    this.disposed = false;
-  }
-  /**
-   * Ensure dimensions are available, initializing the model if needed.
-   * Returns the embedding dimensions for the current model.
-   */
-  async ensureDimensions() {
-    if (this._dimensions === null) {
-      await this.embedText("dimension probe");
-    }
-    if (this._dimensions === null) {
-      throw new Error("Failed to determine embedding dimensions");
-    }
-    return this._dimensions;
-  }
-  /**
-   * Dispose the embedding pipeline to free resources.
-   * Should be called before process exit to prevent ONNX runtime cleanup issues on macOS.
-   * After disposal, this engine cannot be used again.
-   */
-  async dispose() {
-    if (this.extractor !== null) {
-      await this.extractor.dispose();
-      this.extractor = null;
-    }
-    this.initPromise = null;
-    this._dimensions = null;
-    this.disposed = true;
-  }
-};
-
 // src/db/lance.ts
 import { rm as rm2 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import * as lancedb from "@lancedb/lancedb";
 import { LanceSchema } from "@lancedb/lancedb/embedding";
 import { Utf8 } from "apache-arrow";
@@ -6147,17 +6955,19 @@ var HuggingFaceEmbeddingFunction = class extends TextEmbeddingFunction {
   constructor(optionsRaw) {
     super();
     const options = this.resolveVariables(optionsRaw ?? {});
-    this.embeddingConfig = {
-      model: options.model ?? "Xenova/bge-small-en-v1.5",
-      batchSize: options.batchSize ?? 32,
-      dtype: options.dtype ?? "fp32",
-      pooling: options.pooling ?? "mean",
-      normalize: options.normalize ?? true,
-      queryPrefix: options.queryPrefix ?? "",
-      docPrefix: options.docPrefix ?? "",
-      maxInFlightBatches: 1
+    const finetunedPath = getFinetunedModelPath();
+    const model = finetunedPath ?? options.model ?? getConfiguredModelId();
+    const overrides = {
+      maxInFlightBatches: 1,
       // Single-threaded for LanceDB integration
+      ...options.batchSize !== void 0 && { batchSize: options.batchSize },
+      ...options.dtype !== void 0 && { dtype: options.dtype },
+      ...options.pooling !== void 0 && { pooling: options.pooling },
+      ...options.normalize !== void 0 && { normalize: options.normalize },
+      ...options.queryPrefix !== void 0 && { queryPrefix: options.queryPrefix },
+      ...options.docPrefix !== void 0 && { docPrefix: options.docPrefix }
     };
+    this.embeddingConfig = buildEmbeddingConfig(model, overrides);
     this.engine = new EmbeddingEngine(this.embeddingConfig);
   }
   /**
@@ -6233,11 +7043,15 @@ var DocumentMetadataSchema = z5.object({
 }).loose();
 
 // src/db/lance.ts
-var logger6 = createLogger("lance");
+var logger8 = createLogger("lance");
 function isSearchHit(value) {
   if (typeof value !== "object" || value === null) return false;
   return "id" in value && "content" in value && "metadata" in value && "_distance" in value && typeof value.id === "string" && typeof value.content === "string" && typeof value.metadata === "string" && typeof value._distance === "number";
 }
+function isDocumentRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return "id" in value && "content" in value && "metadata" in value && typeof value.id === "string" && typeof value.content === "string" && typeof value.metadata === "string";
+}
 function parseDocumentMetadata(jsonStr) {
   const parsed = DocumentMetadataSchema.parse(JSON.parse(jsonStr));
   return {
@@ -6405,6 +7219,29 @@ var LanceStore = class {
       };
     });
   }
+  /**
+   * Get all documents from a store (for training data generation).
+   * Returns documents in batches to avoid memory issues with large stores.
+   */
+  async getAllDocuments(storeId, options) {
+    const table = await this.getTable(storeId);
+    const limit = options?.limit ?? 1e4;
+    const offset = options?.offset ?? 0;
+    const rawResults = await table.query().limit(limit).offset(offset).toArray();
+    const results = rawResults.filter(isDocumentRecord);
+    return results.map((r) => ({
+      id: createDocumentId(r.id),
+      content: r.content,
+      metadata: parseDocumentMetadata(r.metadata)
+    }));
+  }
+  /**
+   * Count total documents in a store.
+   */
+  async countDocuments(storeId) {
+    const table = await this.getTable(storeId);
+    return table.countRows();
+  }
   async deleteStore(storeId) {
     const tableName = this.getTableName(storeId);
     this.connection ??= await lancedb.connect(this.dataDir);
@@ -6413,11 +7250,11 @@ var LanceStore = class {
       await this.connection.dropTable(tableName);
     }
     this.tables.delete(tableName);
-    const lanceDir = join12(this.dataDir, `${tableName}.lance`);
+    const lanceDir = join13(this.dataDir, `${tableName}.lance`);
     try {
       await rm2(lanceDir, { recursive: true, force: true });
     } catch (error) {
-      logger6.warn({ lanceDir, error }, "Failed to remove .lance directory");
+      logger8.warn({ lanceDir, error }, "Failed to remove .lance directory");
     }
   }
   close() {
@@ -6454,7 +7291,7 @@ var LanceStore = class {
 };
 
 // src/services/index.ts
-var logger7 = createLogger("services");
+var logger9 = createLogger("services");
 var LazyServiceContainer = class {
   // Eagerly initialized (lightweight)
   config;
@@ -6469,6 +7306,8 @@ var LazyServiceContainer = class {
   _manifest = null;
   _embeddings = null;
   _codeGraph = null;
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly -- mutated in lazy getter
+  _reranker = null;
   _search = null;
   _index = null;
   constructor(config, appConfig, dataDir, store, lance, pythonBridge) {
@@ -6485,7 +7324,7 @@ var LazyServiceContainer = class {
    */
   get embeddings() {
     if (this._embeddings === null) {
-      logger7.debug("Lazy-initializing EmbeddingEngine");
+      logger9.debug("Lazy-initializing EmbeddingEngine");
       this._embeddings = new EmbeddingEngine(this.appConfig.embedding);
     }
     return this._embeddings;
@@ -6495,18 +7334,34 @@ var LazyServiceContainer = class {
    */
   get codeGraph() {
     if (this._codeGraph === null) {
-      logger7.debug("Lazy-initializing CodeGraphService");
+      logger9.debug("Lazy-initializing CodeGraphService");
       this._codeGraph = new CodeGraphService(this.dataDir, this.pythonBridge);
     }
     return this._codeGraph;
   }
+  /**
+   * RerankerService is lazily created on first access.
+   * Only created if reranker config exists and is enabled.
+   */
+  get reranker() {
+    if (this._reranker === null && this.appConfig.reranker?.enabled) {
+      logger9.debug("Lazy-initializing RerankerService");
+      this._reranker = new RerankerService(this.appConfig.reranker);
+    }
+    return this._reranker ?? void 0;
+  }
   /**
    * SearchService is lazily created on first access.
    */
   get search() {
     if (this._search === null) {
-      logger7.debug("Lazy-initializing SearchService");
-      this._search = new SearchService(this.lance, this.codeGraph, this.appConfig.search);
+      logger9.debug("Lazy-initializing SearchService");
+      this._search = new SearchService(
+        this.lance,
+        this.codeGraph,
+        this.appConfig.search,
+        this.reranker
+      );
     }
     return this._search;
   }
@@ -6515,14 +7370,15 @@ var LazyServiceContainer = class {
    */
   get index() {
     if (this._index === null) {
-      logger7.debug("Lazy-initializing IndexService");
+      logger9.debug("Lazy-initializing IndexService");
       this._index = new IndexService(this.lance, this.embeddings, {
         codeGraphService: this.codeGraph,
         manifestService: this.manifest,
         chunkSize: this.appConfig.indexing.chunkSize,
         chunkOverlap: this.appConfig.indexing.chunkOverlap,
         concurrency: this.appConfig.indexing.concurrency,
-        ignorePatterns: this.appConfig.indexing.ignorePatterns
+        ignorePatterns: this.appConfig.indexing.ignorePatterns,
+        prependPath: this.appConfig.indexing.prependPath
       });
     }
     return this._index;
@@ -6532,7 +7388,7 @@ var LazyServiceContainer = class {
    */
   get manifest() {
     if (this._manifest === null) {
-      logger7.debug("Lazy-initializing ManifestService");
+      logger9.debug("Lazy-initializing ManifestService");
       this._manifest = new ManifestService(this.dataDir);
     }
     return this._manifest;
@@ -6551,7 +7407,7 @@ var LazyServiceContainer = class {
   }
 };
 async function createLazyServices(configPath, dataDir, projectRoot) {
-  logger7.info({ configPath, dataDir, projectRoot }, "Initializing lazy services");
+  logger9.info({ configPath, dataDir, projectRoot }, "Initializing lazy services");
   const startTime = Date.now();
   const config = new ConfigService(configPath, dataDir, projectRoot);
   const appConfig = await config.load();
@@ -6572,14 +7428,14 @@ async function createLazyServices(configPath, dataDir, projectRoot) {
   await store.initialize();
   await lance.setEmbeddingFunction(appConfig.embedding);
   const durationMs = Date.now() - startTime;
-  logger7.info(
+  logger9.info(
     { dataDir: resolvedDataDir, projectRoot: resolvedProjectRoot, durationMs },
     "Lazy services initialized"
   );
   return new LazyServiceContainer(config, appConfig, resolvedDataDir, store, lance, pythonBridge);
 }
 async function createServices(configPath, dataDir, projectRoot) {
-  logger7.info({ configPath, dataDir, projectRoot }, "Initializing services");
+  logger9.info({ configPath, dataDir, projectRoot }, "Initializing services");
   const config = new ConfigService(configPath, dataDir, projectRoot);
   const appConfig = await config.load();
   const resolvedDataDir = config.resolveDataDir();
@@ -6602,16 +7458,18 @@ async function createServices(configPath, dataDir, projectRoot) {
   await store.initialize();
   const codeGraph = new CodeGraphService(resolvedDataDir, pythonBridge);
   const manifest = new ManifestService(resolvedDataDir);
-  const search = new SearchService(lance, codeGraph, appConfig.search);
+  const reranker = appConfig.reranker?.enabled ? new RerankerService(appConfig.reranker) : void 0;
+  const search = new SearchService(lance, codeGraph, appConfig.search, reranker);
   const index = new IndexService(lance, embeddings, {
     codeGraphService: codeGraph,
     manifestService: manifest,
     chunkSize: appConfig.indexing.chunkSize,
     chunkOverlap: appConfig.indexing.chunkOverlap,
     concurrency: appConfig.indexing.concurrency,
-    ignorePatterns: appConfig.indexing.ignorePatterns
+    ignorePatterns: appConfig.indexing.ignorePatterns,
+    prependPath: appConfig.indexing.prependPath
   });
-  logger7.info(
+  logger9.info(
     { dataDir: resolvedDataDir, projectRoot: resolvedProjectRoot },
     "Services initialized successfully"
   );
@@ -6628,20 +7486,20 @@ async function createServices(configPath, dataDir, projectRoot) {
   };
 }
 async function destroyServices(services) {
-  logger7.info("Shutting down services");
+  logger9.info("Shutting down services");
   const errors = [];
   const isLazyContainer = services instanceof LazyServiceContainer;
   const shouldCleanupSearch = !isLazyContainer || services.hasSearch;
   if (shouldCleanupSearch) {
     services.search.cleanup();
   } else {
-    logger7.debug("Skipping search cleanup (not initialized)");
+    logger9.debug("Skipping search cleanup (not initialized)");
   }
   try {
     await services.pythonBridge.stop();
   } catch (e) {
     const error = e instanceof Error ? e : new Error(String(e));
-    logger7.error({ error }, "Error stopping Python bridge");
+    logger9.error({ error }, "Error stopping Python bridge");
     errors.push(error);
   }
   const shouldDisposeEmbeddings = !isLazyContainer || services.hasEmbeddings;
@@ -6650,17 +7508,17 @@ async function destroyServices(services) {
       await services.embeddings.dispose();
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
-      logger7.error({ error }, "Error disposing EmbeddingEngine");
+      logger9.error({ error }, "Error disposing EmbeddingEngine");
       errors.push(error);
     }
   } else {
-    logger7.debug("Skipping embeddings disposal (not initialized)");
+    logger9.debug("Skipping embeddings disposal (not initialized)");
   }
   try {
     await services.lance.closeAsync();
   } catch (e) {
     const error = e instanceof Error ? e : new Error(String(e));
-    logger7.error({ error }, "Error closing LanceStore");
+    logger9.error({ error }, "Error closing LanceStore");
     errors.push(error);
   }
   await shutdownLogger();
@@ -6694,4 +7552,4 @@ export {
   createServices,
   destroyServices
 };
-//# sourceMappingURL=chunk-WP2GERAJ.js.map
+//# sourceMappingURL=chunk-U27UECDZ.js.map