@takara-ai/miru-code 1.9.0 → 1.10.1

package/src/mcp/index-cache.ts

@@ -49,6 +49,11 @@ type CacheEntry = {
   lastError: Error | null;
 };
 
+export interface IndexCacheDependencies {
+  fromSource?: typeof MiruIndex.fromSource;
+  watch?: typeof watch;
+}
+
 export function mcpWatchEnabled(): boolean {
   const raw = process.env.MIRU_MCP_WATCH;
   return raw !== "0" && raw !== "false";
@@ -76,12 +81,20 @@ export function shouldIgnoreWatchPath(relativePath: string | null | undefined):
 export class IndexCache {
   private readonly content: ContentType[];
   private readonly defaultRef: string | null;
+  private readonly fromSource: typeof MiruIndex.fromSource;
+  private readonly watchSource: typeof watch;
   private readonly entries = new Map<string, CacheEntry>();
   readonly watchers = new Map<string, WatcherHandle>();
 
-  constructor(content: ContentType[] = defaultContentTypes(), defaultRef: string | null = null) {
+  constructor(
+    content: ContentType[] = defaultContentTypes(),
+    defaultRef: string | null = null,
+    dependencies: IndexCacheDependencies = {},
+  ) {
     this.content = content;
     this.defaultRef = defaultRef;
+    this.fromSource = dependencies.fromSource ?? MiruIndex.fromSource;
+    this.watchSource = dependencies.watch ?? watch;
   }
 
   private ensureEntry(cacheKey: string, source: string): CacheEntry {
@@ -128,7 +141,7 @@ export class IndexCache {
   ): Promise<MiruIndex> {
     const entry = this.ensureEntry(cacheKey, source);
     const task = (async () => {
-      const index = await MiruIndex.fromSource(source, this.content, undefined, ref);
+      const index = await this.fromSource(source, this.content, undefined, ref);
       if (!isGitUrl(source)) {
         await index.saveToCache(resolve(source));
       }
@@ -342,7 +355,7 @@ export class IndexCache {
 
     let nativeWatcher: ReturnType<typeof watch> | null = null;
     try {
-      nativeWatcher = watch(resolved, { recursive: true }, (_event, filename) => {
+      nativeWatcher = this.watchSource(resolved, { recursive: true }, (_event, filename) => {
         this.noteFileChange(path, filename);
       });
     } catch {

package/src/mcp/server.ts

@@ -44,8 +44,7 @@ import { getIndexForRepo, type IndexCache, toolText } from "./index-cache.ts";
 import { MiruMcpServer } from "./runtime.ts";
 
 const REPO_DESCRIPTION =
-  "https:// or http:// git URL (e.g. https://github.com/org/repo) or local directory path to index and search. " +
-  "Pass the project root for local workspaces. " +
+  "`repo` is optional. Set a local path or Git URL for another repo. " +
   "The index is built on the first tool call and cached for the session.";
 
 const BENCHMARK_SKIP_NOTES = {
@@ -121,9 +120,26 @@ async function persistBenchmarkQuery(
 
 export function createMcpServer(
   cache: IndexCache,
-  options?: { benchmark?: boolean },
+  options?: {
+    benchmark?: boolean;
+    dependencies?: {
+      withGrepTimeoutFallback?: typeof withGrepTimeoutFallback;
+      benchmarkSearchComparison?: typeof benchmarkSearchComparison;
+      benchmarkLocateComparison?: typeof benchmarkLocateComparison;
+      selectComparableLiteralSearchTool?: typeof selectComparableLiteralSearchTool;
+      readBenchmarkRollup?: typeof readBenchmarkRollup;
+    };
+  },
 ): MiruMcpServer {
+  const defaultRepo = process.cwd();
   const benchmark = options?.benchmark ?? false;
+  const dependencies = options?.dependencies;
+  const runWithGrepFallback = dependencies?.withGrepTimeoutFallback ?? withGrepTimeoutFallback;
+  const compareSearch = dependencies?.benchmarkSearchComparison ?? benchmarkSearchComparison;
+  const compareLocate = dependencies?.benchmarkLocateComparison ?? benchmarkLocateComparison;
+  const selectLiteralBaseline =
+    dependencies?.selectComparableLiteralSearchTool ?? selectComparableLiteralSearchTool;
+  const readRollup = dependencies?.readBenchmarkRollup ?? readBenchmarkRollup;
   const server = new MiruMcpServer(
     {
       name: "miru",
@@ -139,14 +155,14 @@ export function createMcpServer(
   server.registerTool(
     "search",
     {
-      description: `${MCP_SEARCH_TOOL_DESCRIPTION} Indexes \`repo\` on first call; later calls reuse the session cache.`,
+      description: `${MCP_SEARCH_TOOL_DESCRIPTION} Indexes the selected directory or URL on first call; later calls reuse the session cache.`,
       inputSchema: {
         query: z
           .string()
           .describe(
             "Natural language or code query — your default for all code search in this repo.",
           ),
-        repo: z.string().describe(REPO_DESCRIPTION),
+        repo: z.string().optional().describe(REPO_DESCRIPTION),
         include: z
           .array(z.string().min(1))
           .min(1)
@@ -169,15 +185,16 @@ export function createMcpServer(
     },
     async ({ query, repo, include, exclude, dedupe_by_file: dedupeByFile }) => {
       try {
-        const index = await getIndexForRepo(repo, cache);
-        const repoRoot = localRepoRoot(repo);
+        const source = repo ?? defaultRepo;
+        const index = await getIndexForRepo(source, cache);
+        const repoRoot = localRepoRoot(source);
         const k = SEARCH_RESULT_COUNT;
         let skip: BenchmarkSkipReason | undefined;
         if (benchmark && (include || exclude)) {
           skip = "filtered_search";
         } else if (benchmark && repoRoot) {
-          const comparison = await withGrepTimeoutFallback(() =>
-            benchmarkSearchComparison({
+          const comparison = await runWithGrepFallback(() =>
+            compareSearch({
               query,
               repoPath: repoRoot,
               index,
@@ -245,7 +262,7 @@ export function createMcpServer(
           .describe(
             "Alias for `literal` — accepted so a call shaped like `search(query=...)` still resolves as an exact-substring lookup.",
           ),
-        repo: z.string().describe(REPO_DESCRIPTION),
+        repo: z.string().optional().describe(REPO_DESCRIPTION),
         mode: z
           .enum(["count", "locations", "lines"])
           .optional()
@@ -291,19 +308,20 @@ export function createMcpServer(
         return toolErrorText(new Error("locate requires `literal` (exact substring to find)."));
       }
       try {
-        const index = await getIndexForRepo(repo, cache);
+        const source = repo ?? defaultRepo;
+        const index = await getIndexForRepo(source, cache);
 
         let skip: BenchmarkSkipReason | undefined;
-        const repoRoot = localRepoRoot(repo);
+        const repoRoot = localRepoRoot(source);
         if (benchmark && repoRoot && typeof lit === "string") {
           if (locateOpts.limit != null) {
             skip = "limited_locate";
-          } else if (!selectComparableLiteralSearchTool()) {
+          } else if (!selectLiteralBaseline()) {
             skip = "incompatible_literal_baseline";
           }
           if (!skip) {
-            const comparison = await withGrepTimeoutFallback(() =>
-              benchmarkLocateComparison({
+            const comparison = await runWithGrepFallback(() =>
+              compareLocate({
                 literal: lit,
                 repoPath: repoRoot,
                 index,
@@ -343,7 +361,7 @@ export function createMcpServer(
           .number()
           .int()
           .describe("Line from the search hit (`anchor_line` when truncated, else `start_line`)."),
-        repo: z.string().describe(REPO_DESCRIPTION),
+        repo: z.string().optional().describe(REPO_DESCRIPTION),
         before: z
           .number()
           .int()
@@ -360,8 +378,9 @@ export function createMcpServer(
     },
     async ({ file_path: filePath, anchor_line: anchorLine, repo, before, after }) => {
       try {
-        const index = await getIndexForRepo(repo, cache);
-        const repoRoot = localRepoRoot(repo);
+        const source = repo ?? defaultRepo;
+        const index = await getIndexForRepo(source, cache);
+        const repoRoot = localRepoRoot(source);
         const beforeCount = before ?? DEFAULT_EXPAND_BEFORE;
         const afterCount = after ?? DEFAULT_EXPAND_AFTER;
         const { anchor, chunks: expanded } = expandChunksAtLine(
@@ -404,13 +423,14 @@ export function createMcpServer(
           .number()
           .int()
           .describe("Line from the search hit (`anchor_line` when truncated, else `start_line`)."),
-        repo: z.string().describe(REPO_DESCRIPTION),
+        repo: z.string().optional().describe(REPO_DESCRIPTION),
       },
     },
     async ({ file_path: filePath, anchor_line: anchorLine, repo }) => {
       try {
-        const index = await getIndexForRepo(repo, cache);
-        const repoRoot = localRepoRoot(repo);
+        const source = repo ?? defaultRepo;
+        const index = await getIndexForRepo(source, cache);
+        const repoRoot = localRepoRoot(source);
         const chunk = resolveChunk(index.chunks, filePath, anchorLine, repoRoot);
         if (!chunk) {
           return toolText(
@@ -452,7 +472,7 @@ export function createMcpServer(
       },
       async ({ repo }) => {
         try {
-          const rollup = await readBenchmarkRollup({ repo });
+          const rollup = await readRollup({ repo });
           return toolText(JSON.stringify(rollup));
         } catch (err) {
           return toolText(err instanceof Error ? err.message : String(err));

package/src/mcp/stdio.ts

@@ -45,6 +45,21 @@ export class StdioTransport {
   private buffer = "";
   private started = false;
   private abortController: AbortController | null = null;
+  private readonly inputStream: () => ReadableStream<Uint8Array<ArrayBufferLike>>;
+  private readonly writeText: (text: string) => Promise<unknown>;
+
+  constructor(
+    options: {
+      inputStream?: () => ReadableStream<Uint8Array<ArrayBufferLike>>;
+      writeText?: (text: string) => Promise<unknown>;
+      stdin?: { stream: () => ReadableStream<Uint8Array<ArrayBufferLike>> };
+      bunWrite?: (destination: typeof Bun.stdout, text: string) => Promise<unknown>;
+    } = {},
+  ) {
+    this.inputStream = options.inputStream ?? (() => (options.stdin ?? Bun.stdin).stream());
+    this.writeText =
+      options.writeText ?? ((text) => (options.bunWrite ?? Bun.write)(Bun.stdout, text));
+  }
 
   onmessage?: (message: JsonRpcMessage) => void | Promise<void>;
   onerror?: (error: Error) => void;
@@ -56,7 +71,7 @@ export class StdioTransport {
     }
     this.started = true;
     this.abortController = new AbortController();
-    const reader = Bun.stdin.stream().getReader();
+    const reader = this.inputStream().getReader();
     const decoder = new TextDecoder();
 
     try {
@@ -85,7 +100,7 @@ export class StdioTransport {
 
   async send(message: JsonRpcMessage): Promise<void> {
     const line = `${JSON.stringify(message)}\n`;
-    await Bun.write(Bun.stdout, line);
+    await this.writeText(line);
   }
 
   private async append(chunk: string): Promise<void> {

package/src/miru-index.ts

@@ -26,6 +26,31 @@ import { chunkKey, chunkToDict, defaultContentTypes } from "./types.ts";
 import { computeSourceCacheKey, isGitUrl } from "./utils.ts";
 import { indexCacheEpoch } from "./version.ts";
 
+interface FactoryDependencies {
+  getValidatedCache: typeof getValidatedCache;
+  resolveEmbeddingModel: typeof resolveEmbeddingModel;
+  getEmbeddingBackend: (model: string) => EmbeddingBackend;
+  createIndexFromPath: typeof createIndexFromPath;
+  cloneGitRepository: typeof cloneGitRepository;
+  findIndexCachePath: typeof findIndexCachePath;
+  loadCachedIndex: typeof loadCachedIndex;
+  saveBuiltIndex: (index: MiruIndex, path: string) => Promise<void>;
+}
+
+function factoryDependencies(overrides: Partial<FactoryDependencies> = {}): FactoryDependencies {
+  return {
+    getValidatedCache,
+    resolveEmbeddingModel,
+    getEmbeddingBackend,
+    createIndexFromPath,
+    cloneGitRepository,
+    findIndexCachePath,
+    loadCachedIndex,
+    saveBuiltIndex: (index, path) => index.save(path),
+    ...overrides,
+  };
+}
+
 /**
  * In-memory search index over a codebase: BM25 keyword scores plus semantic
  * embeddings, with optional disk cache for reuse across runs.
@@ -171,18 +196,20 @@ export class MiruIndex {
     content: ContentType[] = defaultContentTypes(),
     embeddingModel?: string,
     ref?: string | null,
+    dependencies?: Partial<FactoryDependencies>,
   ): Promise<MiruIndex> {
+    const deps = factoryDependencies(dependencies);
     const cacheKey = computeSourceCacheKey(url, ref);
-    const model = embeddingModel ?? resolveEmbeddingModel();
-    const cached = await getValidatedCache(cacheKey, model, content);
+    const model = embeddingModel ?? deps.resolveEmbeddingModel();
+    const cached = await deps.getValidatedCache(cacheKey, model, content);
     if (cached) {
-      return MiruIndex.loadFromDisk(cached, model);
+      return MiruIndex.loadFromDisk(cached, model, deps);
     }
 
-    const cloneDir = await cloneGitRepository(url, ref);
+    const cloneDir = await deps.cloneGitRepository(url, ref);
     try {
-      const embeddings = getEmbeddingBackend(model);
-      const { bm25, semantic, chunks } = await createIndexFromPath(
+      const embeddings = deps.getEmbeddingBackend(model);
+      const { bm25, semantic, chunks } = await deps.createIndexFromPath(
         cloneDir,
         embeddings,
         content,
@@ -198,7 +225,7 @@ export class MiruIndex {
         root: null,
         content,
       });
-      await index.save(findIndexCachePath(cacheKey));
+      await deps.saveBuiltIndex(index, deps.findIndexCachePath(cacheKey));
       return index;
     } finally {
       await rm(cloneDir, { recursive: true, force: true });
@@ -211,11 +238,12 @@ export class MiruIndex {
     content: ContentType[] = defaultContentTypes(),
     embeddingModel?: string,
     ref?: string | null,
+    dependencies?: Partial<FactoryDependencies>,
   ): Promise<MiruIndex> {
     if (isGitUrl(source)) {
-      return MiruIndex.fromGit(source, content, embeddingModel, ref);
+      return MiruIndex.fromGit(source, content, embeddingModel, ref, dependencies);
     }
-    return MiruIndex.fromPath(source, content, embeddingModel);
+    return MiruIndex.fromPath(source, content, embeddingModel, dependencies);
   }
 
   /**
@@ -229,7 +257,9 @@ export class MiruIndex {
     path: string,
     content: ContentType[] = defaultContentTypes(),
     embeddingModel?: string,
+    dependencies?: Partial<FactoryDependencies>,
   ): Promise<MiruIndex> {
+    const deps = factoryDependencies(dependencies);
     const resolved = resolve(path);
     try {
       const st = await Bun.file(resolved).stat();
@@ -243,14 +273,14 @@ export class MiruIndex {
       throw new Error(`Path does not exist: ${path}`);
     }
 
-    const model = embeddingModel ?? resolveEmbeddingModel();
-    const cached = await getValidatedCache(resolved, model, content);
+    const model = embeddingModel ?? deps.resolveEmbeddingModel();
+    const cached = await deps.getValidatedCache(resolved, model, content);
     if (cached) {
-      return MiruIndex.loadFromDisk(cached, model);
+      return MiruIndex.loadFromDisk(cached, model, deps);
     }
 
-    const embeddings = getEmbeddingBackend(model);
-    const { bm25, semantic, chunks } = await createIndexFromPath(
+    const embeddings = deps.getEmbeddingBackend(model);
+    const { bm25, semantic, chunks } = await deps.createIndexFromPath(
       resolved,
       embeddings,
       content,
@@ -274,15 +304,20 @@ export class MiruIndex {
    * Validates embedding model compatibility via cache metadata. Sets
    * `loadedFromDisk` so callers can avoid redundant cache writes.
    */
-  static async loadFromDisk(path: string, embeddingModel?: string): Promise<MiruIndex> {
-    const model = embeddingModel ?? resolveEmbeddingModel();
-    const { bm25, semantic, chunks, metadata } = await loadCachedIndex(path);
+  static async loadFromDisk(
+    path: string,
+    embeddingModel?: string,
+    dependencies?: Partial<FactoryDependencies>,
+  ): Promise<MiruIndex> {
+    const deps = factoryDependencies(dependencies);
+    const model = embeddingModel ?? deps.resolveEmbeddingModel();
+    const { bm25, semantic, chunks, metadata } = await deps.loadCachedIndex(path);
     const content = (metadata.content_type as ContentType[]) ?? defaultContentTypes();
     const root = metadata.root_path ? String(metadata.root_path) : null;
     const storedFileMtimes = (metadata.file_mtimes as Record<string, number>) ?? {};
 
     return new MiruIndex({
-      embeddings: getEmbeddingBackend(model),
+      embeddings: deps.getEmbeddingBackend(model),
       bm25Index: bm25,
       semanticIndex: semantic,
       chunks,
@@ -387,6 +422,7 @@ export class MiruIndex {
       embeddings: this.embeddings,
       chunks: this.chunksInternal,
       semanticIndex: this.semanticIndex,
+      bm25: this.bm25Index,
       relativePaths,
     });
 

package/src/prompt.ts

@@ -62,22 +62,49 @@ export function applyHiddenPromptChar(
 }
 
 /** Visible-input prompt (not for secrets — use promptHidden for those). */
-export async function promptText(message: string, defaultValue = ""): Promise<string> {
-  const rl = readline.createInterface({ input, output });
+export async function promptText(
+  message: string,
+  defaultValue = "",
+  createInterface: typeof createPromptInterface = createPromptInterface,
+): Promise<string> {
+  const rl = createInterface({ input, output });
+  return promptTextWith(
+    message,
+    defaultValue,
+    (question) => rl.question(question),
+    () => rl.close(),
+  );
+}
+
+export function createPromptInterface(
+  options: { input: typeof input; output: typeof output },
+  factory: typeof readline.createInterface = readline.createInterface,
+): Pick<readline.Interface, "question" | "close"> {
+  return factory(options);
+}
+
+export async function promptTextWith(
+  message: string,
+  defaultValue: string,
+  ask: (question: string) => Promise<string>,
+  close: () => void = () => {},
+): Promise<string> {
   try {
     const suffix = defaultValue ? ` (${defaultValue})` : "";
-    const answer = (await rl.question(`${message}${suffix}: `)).trim();
+    const answer = (await ask(`${message}${suffix}: `)).trim();
     return answer || defaultValue;
   } finally {
-    rl.close();
+    close();
   }
 }
 
 export async function promptHidden(
   message: string,
-  stream: NodeJS.WriteStream = output,
+  stream: { write(text: string): unknown } = output,
+  io: { input?: HiddenPromptInput; exit?: (code: number) => void } = {},
 ): Promise<string> {
-  if (!input.isTTY) {
+  const inputStream = io.input ?? input;
+  if (!inputStream.isTTY) {
     throw new Error(
       "Cannot prompt for API key: stdin is not a TTY. Run `miru setup --key YOUR_KEY` or set TAKARA_API_KEY.",
     );
@@ -85,9 +112,9 @@ export async function promptHidden(
 
   return new Promise((resolve, reject) => {
     stream.write(message);
-    input.setRawMode?.(true);
-    input.resume();
-    input.setEncoding("utf8");
+    inputStream.setRawMode?.(true);
+    inputStream.resume();
+    inputStream.setEncoding("utf8");
 
     let state = createHiddenPromptState();
 
@@ -100,7 +127,7 @@ export async function promptHidden(
           cleanup();
           stream.write("\n");
           reject(new Error("Setup cancelled."));
-          process.exit(130);
+          (io.exit ?? process.exit)(130);
         }
 
         if (result.submit) {
@@ -117,11 +144,21 @@ export async function promptHidden(
     };
 
     const cleanup = () => {
-      input.setRawMode?.(false);
-      input.pause();
-      input.removeListener("data", onData);
+      inputStream.setRawMode?.(false);
+      inputStream.pause();
+      inputStream.removeListener("data", onData);
     };
 
-    input.on("data", onData);
+    inputStream.on("data", onData);
   });
 }
+
+interface HiddenPromptInput {
+  isTTY?: boolean;
+  setRawMode?: (mode: boolean) => void;
+  resume(): void;
+  pause(): void;
+  setEncoding(encoding: "utf8"): unknown;
+  on(event: "data", listener: (chunk: string) => void): unknown;
+  removeListener(event: "data", listener: (chunk: string) => void): unknown;
+}

package/src/ranking/boosting.ts

@@ -209,12 +209,11 @@ function boostSymbolDefinitions(
     const stem = basename(chunk.file_path)
       .replace(/\.[^.]+$/, "")
       .toLowerCase();
-    if (![...names].some((n) => stemMatches(stem, n.toLowerCase()))) {
-      continue;
-    }
-    const tier = definitionTier(chunk, names, boostUnit);
-    if (tier) {
-      boosted.set(key, tier);
+    if ([...names].some((n) => stemMatches(stem, n.toLowerCase()))) {
+      const tier = definitionTier(chunk, names, boostUnit);
+      if (tier) {
+        boosted.set(key, tier);
+      }
     }
   }
 }

package/src/ranking/location.ts

@@ -222,16 +222,12 @@ export function boostExactStemMatches(
       if (GENERIC_STEM_DENY.has(keyword)) {
         continue;
       }
-      if (preferImplementation && stem === keyword && !IMPLEMENTATION_HINTS.has(stem)) {
-        continue;
-      }
-      const keywordNorm = keyword.replace(/[-_]/g, "");
-      if (stem === keyword || stemNorm === keywordNorm) {
-        boosted.set(key, (boosted.get(key) ?? 0) + boost);
-        break;
-      }
-      const parts = keyword.split("-").filter((p) => p.length > 2);
-      if (parts.length > 1 && parts.some((p) => p === stem)) {
+      if (!(preferImplementation && stem === keyword && !IMPLEMENTATION_HINTS.has(stem))) {
+        const keywordNorm = keyword.replace(/[-_]/g, "");
+        if (stem === keyword || stemNorm === keywordNorm) {
+          boosted.set(key, (boosted.get(key) ?? 0) + boost);
+          break;
+        }
       }
     }
   }

package/src/ranking/penalties.ts

@@ -72,7 +72,7 @@ export function rerankTopk(
   const ranked = [...penalised.entries()].sort((a, b) => b[1] - a[1]);
 
   const fileSelected = new Map<string, number>();
-  const selected: { score: number; key: string }[] = [];
+  const selected: { score: number; key: string; chunk: Chunk }[] = [];
   let minSelected = Infinity;
 
   for (const [key, penScore] of ranked) {
@@ -81,31 +81,23 @@ export function rerankTopk(
       continue;
     }
 
-    if (selected.length >= topK && penScore <= minSelected) {
-      break;
-    }
-
-    const already = fileSelected.get(chunk.file_path) ?? 0;
-    let effScore = penScore;
-    if (already >= FILE_SATURATION_THRESHOLD) {
-      const excess = already - FILE_SATURATION_THRESHOLD + 1;
-      effScore *= tuning.fileSaturationDecay ** excess;
-    }
+    if (selected.length < topK || penScore > minSelected) {
+      const already = fileSelected.get(chunk.file_path) ?? 0;
+      let effScore = penScore;
+      if (already >= FILE_SATURATION_THRESHOLD) {
+        const excess = already - FILE_SATURATION_THRESHOLD + 1;
+        effScore *= tuning.fileSaturationDecay ** excess;
+      }
 
-    selected.push({ score: effScore, key });
-    fileSelected.set(chunk.file_path, already + 1);
+      selected.push({ score: effScore, key, chunk });
+      fileSelected.set(chunk.file_path, already + 1);
 
-    if (selected.length >= topK) {
-      minSelected = Math.min(...selected.map((s) => s.score));
+      if (selected.length >= topK) {
+        minSelected = Math.min(...selected.map((s) => s.score));
+      }
     }
   }
 
   selected.sort((a, b) => b.score - a.score);
-  return selected.slice(0, topK).flatMap(({ key, score }) => {
-    const chunk = chunksByKey.get(key);
-    if (!chunk) {
-      return [];
-    }
-    return [[chunk, score] as [Chunk, number]];
-  });
+  return selected.slice(0, topK).map(({ chunk, score }) => [chunk, score]);
 }

package/src/search.ts

@@ -137,11 +137,9 @@ export async function hybridSearch(options: {
 
   const allKeys = new Set([...normalizedSemantic.keys(), ...normalizedBm25.keys()]);
   const sortedKeys = [...allKeys].sort((a, b) => {
-    const ca = chunksByKey.get(a);
-    const cb = chunksByKey.get(b);
-    if (!ca || !cb) {
-      return 0;
-    }
+    // Every score key was produced from a chunk in this query.
+    const ca = chunksByKey.get(a) as Chunk;
+    const cb = chunksByKey.get(b) as Chunk;
     return ca.start_line - cb.start_line;
   });
 
@@ -164,13 +162,7 @@ export async function hybridSearch(options: {
   return [...combinedScores.entries()]
     .sort((a, b) => b[1] - a[1])
     .slice(0, topK)
-    .flatMap(([key, score]) => {
-      const chunk = chunksByKey.get(key);
-      if (!chunk) {
-        return [];
-      }
-      return [{ chunk, score }];
-    });
+    .map(([key, score]) => ({ chunk: chunksByKey.get(key) as Chunk, score }));
 }
 
 export async function searchSemanticOnly(options: {