@takara-ai/miru-code 0.5.0 → 0.6.0

package/README.md

@@ -6,6 +6,12 @@ Find code by meaning, not grep. Miru returns the best **chunks** (path, lines, s
 
 **Requires:** [Bun](https://bun.sh) 1.1+ · [Takara API key](https://takara.ai)
 
+## Privacy and API usage
+
+Miru sends **file contents** to the [Takara inference API](https://takara.ai) when building an index and when embedding search queries. Chunks from your repo are transmitted over HTTPS to generate embeddings. API usage may incur cost depending on your Takara plan.
+
+If you index proprietary code, make sure that sending snippets to Takara's endpoint fits your security and compliance requirements. Use `MIRU_WORKSPACE_ROOT` to restrict MCP indexing to a single workspace directory.
+
 ## Install
 
 ```bash
@@ -143,6 +149,9 @@ const results = await index.search({ query: "BM25 tokenize", topK: 10 });
 |----------|-------|
 | `TAKARA_API_KEY` | Required |
 | `MIRU_OPENAI_BASE_URL` | Default `https://infer.takara.ai/v1` |
+| `MIRU_WORKSPACE_ROOT` | Restrict MCP local `repo` paths to this directory |
+| `MIRU_MAX_INDEX_FILES` | Cap files indexed per operation |
+| `MIRU_ALLOW_HTTP_GIT` | Set `1` to allow plain `http://` git clones |
 | `MIRU_MCP_WATCH` | Set `0` to disable MCP file watch |
 | `NO_COLOR` | Disable CLI colors |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takara-ai/miru-code",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Miru (見る) — hybrid code search for agents. Bun, TypeScript, Takara embeddings.",
   "type": "module",
   "license": "MIT",
@@ -53,6 +53,8 @@
     "benchmark:ab": "bun run scripts/search-ab-local.ts",
     "benchmark:ab-multi": "bun run scripts/search-ab-multi.ts",
     "benchmark:recall": "bun run scripts/benchmark-recall-tokens.ts",
+    "benchmark:vs-grep": "bun run scripts/benchmark-miru-vs-grep.ts",
+    "benchmark:workflow": "bun run scripts/benchmark-workflow-tokens.ts",
     "benchmark:quality": "bun run scripts/benchmark-quality.ts",
     "benchmark:quantization": "bun run scripts/benchmark-quantization.ts"
   },

package/src/agents.ts

@@ -1,9 +1,6 @@
 import { mkdir, readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import {
-  buildSubagentBody,
-  type NativeToolNames,
-} from "./installer/search-policy.ts";
+import { buildSubagentBody, type NativeToolNames } from "./installer/search-policy.ts";
 
 export type AgentId = "claude" | "copilot" | "cursor" | "gemini" | "kiro" | "opencode";
 

package/src/cli-ui.ts

@@ -1,4 +1,5 @@
 import type { SearchResult } from "./types.ts";
+import { formatRelevanceScore } from "./utils.ts";
 
 const ANSI = {
   reset: "\x1b[0m",
@@ -145,6 +146,8 @@ export function formatSearchResultsPretty(query: string, results: SearchResult[]
   lines.push(bold(label) + dim(` for `) + cyan(`"${query}"`));
   lines.push("");
 
+  const maxScore = results.reduce((max, result) => Math.max(max, result?.score ?? 0), 0);
+
   for (let i = 0; i < results.length; i++) {
     const result = results[i];
     if (!result) {
@@ -154,7 +157,7 @@ export function formatSearchResultsPretty(query: string, results: SearchResult[]
     const location = `${chunk.file_path}:${chunk.start_line}-${chunk.end_line}`;
     const lang = chunk.language ? dim(`  ${chunk.language}`) : "";
     const rank = dim(`[${i + 1}]`);
-    const scoreText = magenta(score.toFixed(3));
+    const scoreText = magenta(formatRelevanceScore(score, maxScore));
 
     lines.push(`${rank} ${scoreText}  ${bold(location)}${lang}`);
     lines.push(dim("─".repeat(Math.min(PREVIEW_WIDTH, 52))));

package/src/cli.ts

@@ -397,15 +397,7 @@ async function runCli(argv: string[]): Promise<void> {
     }
     const line = Number(lineRaw);
     const path = resolveSearchPath(sizedRest[2] ?? process.cwd());
-    try {
-      await runFindRelated(path, filePath, line, topK, content, jsonFlag);
-    } catch (err) {
-      if (err instanceof RelatedChunkNotFoundError) {
-        fail(err.message);
-        process.exit(1);
-      }
-      throw err;
-    }
+    await runFindRelated(path, filePath, line, topK, content, jsonFlag);
     return;
   }
 

package/src/concurrency.ts

@@ -11,11 +11,7 @@ export function resolveCpuCount(): number {
 
 /** Worker pool size: logical CPUs minus 2, minimum 1. Override with MIRU_CONCURRENCY. */
 export function resolveWorkerConcurrency(): number {
-  const raw =
-    process.env.MIRU_CONCURRENCY ??
-    process.env.SEMBLE_CONCURRENCY ??
-    process.env.MIRU_WORKERS ??
-    process.env.SEMBLE_WORKERS;
+  const raw = process.env.MIRU_CONCURRENCY ?? process.env.MIRU_WORKERS;
   if (raw) {
     const n = Number(raw);
     if (Number.isFinite(n) && n >= 1) {

package/src/embeddings/openai.ts

@@ -32,14 +32,14 @@ export interface EmbeddingBackend {
 
 export function resolveEmbeddingModel(): string {
   return envFirstString(
-    ["MIRU_OPENAI_EMBEDDING_MODEL", "SEMBLE_OPENAI_EMBEDDING_MODEL", "OPENAI_EMBEDDING_MODEL"],
+    ["MIRU_OPENAI_EMBEDDING_MODEL", "OPENAI_EMBEDDING_MODEL"],
     DEFAULT_MODEL,
   );
 }
 
 export function resolveMaxEmbedChars(): number {
   return (
-    envOptionalInt(["MIRU_MAX_EMBED_CHARS", "SEMBLE_MAX_EMBED_CHARS"], 256) ??
+    envOptionalInt(["MIRU_MAX_EMBED_CHARS"], 256) ??
     DEFAULT_MAX_EMBED_CHARS
   );
 }
@@ -73,13 +73,26 @@ function stripLoneSurrogates(text: string): string {
 
 export function sanitizeEmbeddingInput(text: string): string {
   const out = stripLoneSurrogates(text);
-  // Some OpenAI-compatible gateways mis-handle backslash escapes in JSON text
-  // payloads. Keep a benchmark fallback mode to forcefully neutralize them.
-  const mode = process.env.MIRU_EMBED_ESCAPE_MODE ?? process.env.SEMBLE_EMBED_ESCAPE_MODE ?? "quad";
+  const mode = process.env.MIRU_EMBED_ESCAPE_MODE ?? "preserve";
+  if (mode === "quad") {
+    return out.replaceAll("\\", "\\\\\\\\");
+  }
   if (mode === "strip") {
     return out.replaceAll("\\", "/");
   }
-  return out.replaceAll("\\", "\\\\\\\\");
+  return out;
+}
+
+const TRANSIENT_EMBED_STATUSES = new Set([429, 500, 502, 503, 504]);
+const MAX_TRANSIENT_EMBED_RETRIES = 4;
+
+function isTransientEmbeddingError(err: unknown): boolean {
+  const status = (err as { status?: number }).status;
+  return status !== undefined && TRANSIENT_EMBED_STATUSES.has(status);
+}
+
+function transientEmbedBackoffMs(attempt: number): number {
+  return Math.min(250 * 2 ** attempt, 4000);
 }
 
 function isPayloadTooLargeError(err: unknown): boolean {
@@ -95,11 +108,7 @@ function isPayloadTooLargeError(err: unknown): boolean {
 }
 
 export function resolveEmbeddingDimensions(model?: string): number | undefined {
-  const fromEnv = envOptionalInt([
-    "MIRU_EMBEDDING_DIMENSIONS",
-    "SEMBLE_EMBEDDING_DIMENSIONS",
-    "OPENAI_EMBEDDING_DIMENSIONS",
-  ]);
+  const fromEnv = envOptionalInt(["MIRU_EMBEDDING_DIMENSIONS", "OPENAI_EMBEDDING_DIMENSIONS"]);
   if (fromEnv != null) {
     return fromEnv;
   }
@@ -108,17 +117,14 @@ export function resolveEmbeddingDimensions(model?: string): number | undefined {
 
 export function resolveEmbeddingBatchSize(): number {
   return (
-    envOptionalInt([
-      "MIRU_EMBEDDING_BATCH_SIZE",
-      "SEMBLE_EMBEDDING_BATCH_SIZE",
-      "OPENAI_EMBEDDING_BATCH_SIZE",
-    ]) ?? DEFAULT_BATCH_SIZE
+    envOptionalInt(["MIRU_EMBEDDING_BATCH_SIZE", "OPENAI_EMBEDDING_BATCH_SIZE"]) ??
+    DEFAULT_BATCH_SIZE
   );
 }
 
 export function resolveEmbeddingBaseUrl(): string {
   return envFirstString(
-    ["MIRU_OPENAI_BASE_URL", "SEMBLE_OPENAI_BASE_URL", "OPENAI_BASE_URL"],
+    ["MIRU_OPENAI_BASE_URL", "OPENAI_BASE_URL"],
     DEFAULT_BASE_URL,
   ).replace(/\/$/, "");
 }
@@ -282,23 +288,42 @@ export class OpenAIEmbeddingBackend implements EmbeddingBackend {
     return out;
   }
 
+  private async requestEmbeddings(texts: string[]): Promise<EmbeddingResponse> {
+    let lastErr: unknown;
+    for (let attempt = 0; attempt <= MAX_TRANSIENT_EMBED_RETRIES; attempt++) {
+      try {
+        const started = performance.now();
+        const response = await this.client.createEmbeddings(
+          texts,
+          this.model,
+          this.requestedDimensions,
+        );
+        const elapsed = performance.now() - started;
+        this.stats.requests += 1;
+        this.stats.inputItems += texts.length;
+        this.stats.inputChars += texts.reduce((acc, text) => acc + text.length, 0);
+        this.stats.totalRttMs += elapsed;
+        this.stats.maxRttMs = Math.max(this.stats.maxRttMs, elapsed);
+        return response;
+      } catch (err: unknown) {
+        lastErr = err;
+        if (isTransientEmbeddingError(err) && attempt < MAX_TRANSIENT_EMBED_RETRIES) {
+          this.stats.retries += 1;
+          await Bun.sleep(transientEmbedBackoffMs(attempt));
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastErr;
+  }
+
   private async embedBatchRawWithRetry(texts: string[]): Promise<Float32Array[]> {
     if (texts.length === 0) {
       return [];
     }
     try {
-      const started = performance.now();
-      const response = await this.client.createEmbeddings(
-        texts,
-        this.model,
-        this.requestedDimensions,
-      );
-      const elapsed = performance.now() - started;
-      this.stats.requests += 1;
-      this.stats.inputItems += texts.length;
-      this.stats.inputChars += texts.reduce((acc, text) => acc + text.length, 0);
-      this.stats.totalRttMs += elapsed;
-      this.stats.maxRttMs = Math.max(this.stats.maxRttMs, elapsed);
+      const response = await this.requestEmbeddings(texts);
       const vectors = vectorsFromResponse(response.data, texts.length);
       for (const vec of vectors) {
         if (this.requestedDimensions != null && vec.length !== this.requestedDimensions) {
@@ -341,7 +366,12 @@ export class OpenAIEmbeddingBackend implements EmbeddingBackend {
         const rightText = text.slice(mid);
         const left = await this.embedBatchRawWithRetry([leftText]);
         const right = await this.embedBatchRawWithRetry([rightText]);
-        return [...left, ...right];
+        const parts = [left[0], right[0]].filter((vec): vec is Float32Array => vec !== undefined);
+        if (parts.length === 0) {
+          this.stats.errors += 1;
+          throw err;
+        }
+        return [poolWindowVectors(parts)];
       }
       this.stats.errors += 1;
       throw err;

package/src/git.ts

@@ -7,7 +7,7 @@ const DEFAULT_CLONE_TIMEOUT_SEC = 60;
 
 export async function cloneGitRepository(url: string, ref?: string | null): Promise<string> {
   const timeoutSec =
-    envOptionalInt(["MIRU_CLONE_TIMEOUT", "SEMBLE_CLONE_TIMEOUT"], 1) ?? DEFAULT_CLONE_TIMEOUT_SEC;
+    envOptionalInt(["MIRU_CLONE_TIMEOUT"], 1) ?? DEFAULT_CLONE_TIMEOUT_SEC;
   const dir = await mkdtemp(join(tmpdir(), "miru-git-"));
   const args = ["clone", "--depth", "1"];
   if (ref) {

package/src/index/create.ts

@@ -3,47 +3,52 @@ import { chunkSource } from "../chunking/chunking.ts";
 import { resolveWorkerConcurrency } from "../concurrency.ts";
 import type { EmbeddingBackend } from "../embeddings/openai.ts";
 import { envOptionalInt } from "../env.ts";
+import { searchImprovementsEnabled } from "../ranking/features.ts";
 import { tokenize } from "../tokens.ts";
 import type { Chunk, ContentType } from "../types.ts";
 import { BM25Index } from "./bm25.ts";
+import { loadRootEntryChunks } from "./entry-chunks.ts";
 import { walkFiles } from "./file-walker.ts";
 import { detectLanguage, getExtensions, getFileStatus, readFileText } from "./files.ts";
 import type { SemanticIndex } from "./semantic-index.ts";
-import { loadRootEntryChunks } from "./entry-chunks.ts";
 import { enrichForBm25 } from "./sparse.ts";
 import { buildSemanticIndex } from "./vector-storage.ts";
-import { searchImprovementsEnabled } from "../ranking/features.ts";
 
 const DEFAULT_PIPELINE_EMBED_BATCH = 64;
 const DEFAULT_PIPELINE_EMBED_INFLIGHT = 8;
 
 function resolvePipelineEmbedBatch(): number {
   return (
-    envOptionalInt(["MIRU_PIPELINE_EMBED_BATCH", "SEMBLE_PIPELINE_EMBED_BATCH"], 1) ??
+    envOptionalInt(["MIRU_PIPELINE_EMBED_BATCH"], 1) ??
     DEFAULT_PIPELINE_EMBED_BATCH
   );
 }
 
 function resolvePipelineEmbedInflight(): number {
   return (
-    envOptionalInt(["MIRU_PIPELINE_EMBED_INFLIGHT", "SEMBLE_PIPELINE_EMBED_INFLIGHT"], 1) ??
+    envOptionalInt(["MIRU_PIPELINE_EMBED_INFLIGHT"], 1) ??
     DEFAULT_PIPELINE_EMBED_INFLIGHT
   );
 }
 
+function resolveMaxIndexFiles(): number | undefined {
+  return envOptionalInt(["MIRU_MAX_INDEX_FILES"], 1);
+}
+
 export async function createIndexFromPath(
   path: string,
   embeddings: EmbeddingBackend,
   content: ContentType[] = ["code"],
   displayRoot?: string,
 ): Promise<{ bm25: BM25Index; semantic: SemanticIndex; chunks: Chunk[] }> {
-  const profile = process.env.MIRU_PROFILE === "1" || process.env.SEMBLE_PROFILE === "1";
+  const profile = process.env.MIRU_PROFILE === "1";
   const started = performance.now();
   let fileProcessMs = 0;
   let embedBackpressureWaitMs = 0;
   let fileEnumerated = 0;
   let fileTasks = 0;
   let emptyFileTasks = 0;
+  let fileErrors = 0;
 
   if (profile && "resetStats" in embeddings && typeof embeddings.resetStats === "function") {
     embeddings.resetStats();
@@ -55,6 +60,7 @@ export async function createIndexFromPath(
   const fileConcurrency = resolveWorkerConcurrency();
   const embedBatchSize = resolvePipelineEmbedBatch();
   const maxEmbedInflight = resolvePipelineEmbedInflight();
+  const maxIndexFiles = resolveMaxIndexFiles();
   const readyBySeq = new Map<number, Chunk[]>();
   const pendingEmbedChunks: Chunk[] = [];
   const emittedChunkBatches: Chunk[][] = [];
@@ -76,7 +82,7 @@ export async function createIndexFromPath(
       const chunkPath = displayRoot ? relative(root, filePath).replace(/\\/g, "/") : filePath;
       return chunkSource(source, chunkPath, language);
     } catch {
-      emptyFileTasks++;
+      fileErrors++;
       return [];
     } finally {
       fileProcessMs += performance.now() - t;
@@ -136,6 +142,9 @@ export async function createIndexFromPath(
 
   for await (const filePath of walkFiles(resolved, extensions)) {
     fileEnumerated++;
+    if (maxIndexFiles != null && fileEnumerated > maxIndexFiles) {
+      throw new Error(`Index file budget exceeded: max ${maxIndexFiles} files per operation`);
+    }
     while (runningFiles.size >= fileConcurrency) {
       await Promise.race(runningFiles);
     }
@@ -148,10 +157,7 @@ export async function createIndexFromPath(
   }
 
   if (searchImprovementsEnabled()) {
-    const entryChunks = await loadRootEntryChunks(
-      resolved,
-      displayRoot ? root : undefined,
-    );
+    const entryChunks = await loadRootEntryChunks(resolved, displayRoot ? root : undefined);
     if (entryChunks.length > 0) {
       readyBySeq.set(fileSeq++, entryChunks);
       flushReadySequentialChunks();
@@ -187,6 +193,7 @@ export async function createIndexFromPath(
         file_enumerated: fileEnumerated,
         file_tasks: fileTasks,
         empty_or_skipped_files: emptyFileTasks,
+        file_errors: fileErrors,
         chunks: chunks.length,
         vectors: vectors.length,
         pipeline: {

package/src/index/vector-storage.ts

@@ -6,7 +6,7 @@ export type SemanticStorage = "int8" | "float32";
 
 /** Default: int8 quantized vectors (~4x less RAM). Set MIRU_FLOAT_VECTORS=1 for float32. */
 export function resolveSemanticStorage(): SemanticStorage {
-  return process.env.MIRU_FLOAT_VECTORS === "1" || process.env.SEMBLE_FLOAT_VECTORS === "1"
+  return process.env.MIRU_FLOAT_VECTORS === "1"
     ? "float32"
     : "int8";
 }

package/src/installer/prompt.ts

@@ -21,23 +21,55 @@ function writeRaw(text: string): void {
   output.write(text);
 }
 
-function createFrameWriter(): (lines: string[]) => void {
-  let previousLineCount = 0;
+function moveCursorUp(lines: number): void {
+  if (lines > 0) {
+    writeRaw(`${ESC}[${lines}A`);
+  }
+}
 
-  return (lines: string[]) => {
-    if (previousLineCount > 0) {
-      writeRaw(`${ESC}[${previousLineCount}A${CURSOR_START}`);
-    }
-    writeRaw(`${CLEAR_LINE}${lines.join(`\n${CLEAR_LINE}`)}\n`);
-    const extra = previousLineCount - lines.length;
-    if (extra > 0) {
-      for (let i = 0; i < extra; i++) {
-        writeRaw(`${CLEAR_LINE}\n`);
-      }
-      writeRaw(`${ESC}[${extra}A${CURSOR_START}`);
-    }
-    previousLineCount = lines.length;
-  };
+function moveCursorDown(lines: number): void {
+  if (lines > 0) {
+    writeRaw(`${ESC}[${lines}B`);
+  }
+}
+
+function rewriteLineAtOffsetFromBottom(offsetFromBottom: number, content: string): void {
+  moveCursorUp(offsetFromBottom);
+  writeRaw(`${CURSOR_START}${CLEAR_LINE}${content}`);
+  moveCursorDown(offsetFromBottom);
+}
+
+const MULTI_SELECT_HEADER_LINES = 3;
+const MULTI_SELECT_TRAILER_LINES = 2;
+
+function multiSelectTotalLines(itemCount: number): number {
+  return MULTI_SELECT_HEADER_LINES + itemCount + MULTI_SELECT_TRAILER_LINES;
+}
+
+function multiSelectItemOffsetFromBottom(itemIndex: number, itemCount: number): number {
+  return multiSelectTotalLines(itemCount) - (MULTI_SELECT_HEADER_LINES + itemIndex);
+}
+
+function formatMultiSelectItemLine(
+  item: { label: string; checked: boolean },
+  selected: boolean,
+): string {
+  const pointer = selected ? cyan("›") : " ";
+  const mark = item.checked ? cyan("[x]") : dim("[ ]");
+  const label = selected ? bold(item.label) : item.label;
+  return `  ${pointer} ${mark} ${label}`;
+}
+
+function updateMultiSelectItemRow(
+  item: { label: string; checked: boolean },
+  itemIndex: number,
+  itemCount: number,
+  selected: boolean,
+): void {
+  rewriteLineAtOffsetFromBottom(
+    multiSelectItemOffsetFromBottom(itemIndex, itemCount),
+    formatMultiSelectItemLine(item, selected),
+  );
 }
 
 function readKey(): Promise<Buffer> {
@@ -125,11 +157,7 @@ function buildMultiSelectLines<T>(
     if (!item) {
       continue;
     }
-    const selected = i === cursor;
-    const pointer = selected ? cyan("›") : " ";
-    const mark = item.checked ? cyan("[x]") : dim("[ ]");
-    const label = selected ? bold(item.label) : item.label;
-    lines.push(`  ${pointer} ${mark} ${label}`);
+    lines.push(formatMultiSelectItemLine(item, i === cursor));
   }
   lines.push("");
   lines.push(dim(footer));
@@ -150,11 +178,12 @@ export async function promptMultiSelect<T>(
 
   const footer = "↑↓ move  space toggle  a all  enter confirm  ctrl-c cancel";
   let cursor = 0;
-  const drawFrame = createFrameWriter();
+  const itemCount = items.length;
 
   return withRawMode(async () => {
+    writeRaw(`${buildMultiSelectLines(title, items, cursor, footer).join("\n")}\n`);
+
     while (true) {
-      drawFrame(buildMultiSelectLines(title, items, cursor, footer));
       const key = parseKey(await readKey());
 
       if (key === "ctrl-c") {
@@ -166,33 +195,74 @@ export async function promptMultiSelect<T>(
         return items.filter((item) => item.checked).map((item) => item.value);
       }
       if (key === "up") {
-        cursor = Math.max(0, cursor - 1);
+        if (cursor > 0) {
+          const previous = cursor;
+          cursor--;
+          const previousItem = items[previous];
+          const currentItem = items[cursor];
+          if (previousItem) {
+            updateMultiSelectItemRow(previousItem, previous, itemCount, false);
+          }
+          if (currentItem) {
+            updateMultiSelectItemRow(currentItem, cursor, itemCount, true);
+          }
+        }
       } else if (key === "down") {
-        cursor = Math.min(items.length - 1, cursor + 1);
+        if (cursor < items.length - 1) {
+          const previous = cursor;
+          cursor++;
+          const previousItem = items[previous];
+          const currentItem = items[cursor];
+          if (previousItem) {
+            updateMultiSelectItemRow(previousItem, previous, itemCount, false);
+          }
+          if (currentItem) {
+            updateMultiSelectItemRow(currentItem, cursor, itemCount, true);
+          }
+        }
       } else if (key === "space") {
         const item = items[cursor];
         if (item) {
           item.checked = !item.checked;
+          updateMultiSelectItemRow(item, cursor, itemCount, true);
         }
       } else if (key === "all") {
         const allChecked = items.every((item) => item.checked);
-        for (const item of items) {
+        for (let i = 0; i < items.length; i++) {
+          const item = items[i];
+          if (!item) {
+            continue;
+          }
           item.checked = !allChecked;
+          updateMultiSelectItemRow(item, i, itemCount, i === cursor);
         }
       }
     }
   });
 }
 
-function buildConfirmLines(question: string, yesSelected: boolean): string[] {
+function buildConfirmPromptLine(question: string, yesSelected: boolean): string {
   const yes = yesSelected ? green(bold(" Yes ")) : dim(" Yes ");
   const no = yesSelected ? dim(" No ") : green(bold(" No "));
+  return `${question}  ${yes} / ${no}`;
+}
+
+function buildConfirmLines(question: string, yesSelected: boolean): string[] {
   return [
-    `${question}  ${yes} / ${no}`,
+    buildConfirmPromptLine(question, yesSelected),
     dim("←→ or y/n to choose  enter to confirm  ctrl-c to cancel"),
   ];
 }
 
+const CONFIRM_PROMPT_LINES = 2;
+
+function updateConfirmPromptLine(question: string, yesSelected: boolean): void {
+  rewriteLineAtOffsetFromBottom(
+    CONFIRM_PROMPT_LINES,
+    buildConfirmPromptLine(question, yesSelected),
+  );
+}
+
 export async function promptConfirm(question: string, defaultYes = true): Promise<boolean> {
   if (!input.isTTY) {
     const rl = readline.createInterface({ input, output });
@@ -209,11 +279,11 @@ export async function promptConfirm(question: string, defaultYes = true): Promis
   }
 
   let yesSelected = defaultYes;
-  const drawFrame = createFrameWriter();
 
   return withRawMode(async () => {
+    writeRaw(`${buildConfirmLines(question, yesSelected).join("\n")}\n`);
+
     while (true) {
-      drawFrame(buildConfirmLines(question, yesSelected));
       const key = parseKey(await readKey());
 
       if (key === "ctrl-c") {
@@ -225,9 +295,15 @@ export async function promptConfirm(question: string, defaultYes = true): Promis
         return yesSelected;
       }
       if (key === "left" || key === "no") {
-        yesSelected = false;
+        if (yesSelected) {
+          yesSelected = false;
+          updateConfirmPromptLine(question, yesSelected);
+        }
       } else if (key === "right" || key === "yes") {
-        yesSelected = true;
+        if (!yesSelected) {
+          yesSelected = true;
+          updateConfirmPromptLine(question, yesSelected);
+        }
       }
     }
   });

package/src/mcp/index-cache.ts

@@ -3,7 +3,12 @@ import { resolve } from "node:path";
 import { normalizeRelativePath, relativePathFromRoot } from "../index/incremental.ts";
 import { MiruIndex } from "../miru-index.ts";
 import type { ContentType } from "../types.ts";
-import { computeSourceCacheKey, isGitUrl } from "../utils.ts";
+import {
+  computeSourceCacheKey,
+  isAllowedRepoSource,
+  isGitUrl,
+  validateLocalRepoPath,
+} from "../utils.ts";
 
 const CACHE_MAX_SIZE = 10;
 
@@ -28,7 +33,10 @@ const WATCH_IGNORED_DIR_NAMES = new Set([
   ".eggs",
 ]);
 
+type WatcherHandle = ReturnType<typeof watch>;
+
 type CacheEntry = {
+  source: string;
   index: MiruIndex | null;
   task: Promise<MiruIndex> | null;
   pendingPaths: Set<string>;
@@ -37,7 +45,7 @@ type CacheEntry = {
 };
 
 export function mcpWatchEnabled(): boolean {
-  const raw = process.env.MIRU_MCP_WATCH ?? process.env.SEMBLE_MCP_WATCH;
+  const raw = process.env.MIRU_MCP_WATCH;
   return raw !== "0" && raw !== "false";
 }
 
@@ -59,15 +67,14 @@ export class IndexCache {
   private readonly content: ContentType[];
   private readonly defaultRef: string | null;
   private readonly entries = new Map<string, CacheEntry>();
-  private watcher: ReturnType<typeof watch> | null = null;
-  private watchedSource: string | null = null;
+  readonly watchers = new Map<string, WatcherHandle>();
 
   constructor(content: ContentType[] = ["code"], defaultRef: string | null = null) {
     this.content = content;
     this.defaultRef = defaultRef;
   }
 
-  private ensureEntry(cacheKey: string): CacheEntry {
+  private ensureEntry(cacheKey: string, source: string): CacheEntry {
     let entry = this.entries.get(cacheKey);
     if (!entry) {
       if (this.entries.size >= CACHE_MAX_SIZE) {
@@ -77,6 +84,7 @@ export class IndexCache {
         }
       }
       entry = {
+        source,
         index: null,
         task: null,
         pendingPaths: new Set(),
@@ -89,9 +97,19 @@ export class IndexCache {
   }
 
   private clearEntry(cacheKey: string): void {
+    const entry = this.entries.get(cacheKey);
+    if (entry && !isGitUrl(entry.source)) {
+      this.stopWatcher(resolve(entry.source));
+    }
     this.entries.delete(cacheKey);
   }
 
+  private stopWatcher(resolvedPath: string): void {
+    const watcher = this.watchers.get(resolvedPath);
+    watcher?.close();
+    this.watchers.delete(resolvedPath);
+  }
+
   private startBuild(
     source: string,
     ref: string | null | undefined,
@@ -105,7 +123,7 @@ export class IndexCache {
       return index;
     })();
 
-    const entry = this.ensureEntry(cacheKey);
+    const entry = this.ensureEntry(cacheKey, source);
     entry.task = task;
     void task
       .then((index) => {
@@ -126,7 +144,7 @@ export class IndexCache {
   async get(source: string, ref?: string | null): Promise<MiruIndex> {
     const resolvedRef = ref ?? this.defaultRef;
     const cacheKey = computeSourceCacheKey(source, resolvedRef);
-    const entry = this.ensureEntry(cacheKey);
+    const entry = this.ensureEntry(cacheKey, source);
 
     if (!entry.task) {
       this.startBuild(source, resolvedRef, cacheKey);
@@ -151,7 +169,7 @@ export class IndexCache {
 
   private queueIndexedPaths(source: string, index: MiruIndex): void {
     const cacheKey = computeSourceCacheKey(source);
-    const entry = this.ensureEntry(cacheKey);
+    const entry = this.ensureEntry(cacheKey, source);
     for (const chunk of index.chunks) {
       entry.pendingPaths.add(normalizeRelativePath(chunk.file_path));
     }
@@ -161,7 +179,10 @@ export class IndexCache {
   /** macOS recursive fs.watch often omits filename; refresh all indexed paths incrementally. */
   private noteAmbiguousDirectoryChange(source: string): void {
     const cacheKey = computeSourceCacheKey(source);
-    const entry = this.ensureEntry(cacheKey);
+    const entry = this.entries.get(cacheKey);
+    if (!entry) {
+      return;
+    }
 
     if (entry.index) {
       this.queueIndexedPaths(source, entry.index);
@@ -186,7 +207,10 @@ export class IndexCache {
     }
 
     const cacheKey = computeSourceCacheKey(source);
-    const entry = this.ensureEntry(cacheKey);
+    const entry = this.entries.get(cacheKey);
+    if (!entry) {
+      return;
+    }
     const rel = relativePathFromRoot(source, filename);
     if (!rel) {
       return;
@@ -246,29 +270,31 @@ export class IndexCache {
     if (!mcpWatchEnabled() || isGitUrl(source)) {
       return;
     }
-    const resolved = resolve(source);
-    if (this.watchedSource === resolved) {
-      return;
-    }
-    this.watchedSource = resolved;
-    this.startWatcher(resolved);
+    this.startWatcher(source);
   }
 
   startWatcher(path: string): void {
     const resolved = resolve(path);
-    if (this.watcher) {
-      this.watcher.close();
+    if (this.watchers.has(resolved)) {
+      return;
     }
 
-    this.watcher = watch(resolved, { recursive: true }, (_event, filename) => {
+    const watcher = watch(resolved, { recursive: true }, (_event, filename) => {
       this.noteFileChange(resolved, filename);
     });
+    this.watchers.set(resolved, watcher);
+  }
+
+  get watcher(): WatcherHandle | null {
+    const handles = [...this.watchers.values()];
+    return handles[handles.length - 1] ?? null;
   }
 
   close(): void {
-    this.watcher?.close();
-    this.watcher = null;
-    this.watchedSource = null;
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
     this.entries.clear();
   }
 }
@@ -284,12 +310,19 @@ export async function getIndexForRepo(
     );
   }
 
-  if (isGitUrl(repo) && !repo.startsWith("https://") && !repo.startsWith("http://")) {
+  if (isGitUrl(repo) && !isAllowedRepoSource(repo)) {
+    if (repo.startsWith("http://")) {
+      throw new Error(
+        "Plain http:// git URLs are disabled by default. Set MIRU_ALLOW_HTTP_GIT=1 to opt in.",
+      );
+    }
     throw new Error(
-      `Only https://, http://, or local directory paths are accepted as \`repo\`. Got: ${repo}`,
+      `Only https:// git URLs or local directory paths are accepted as \`repo\`. Got: ${repo}`,
     );
   }
 
+  validateLocalRepoPath(repo);
+
   try {
     return await cache.get(repo, ref);
   } catch (err) {

package/src/mcp/server.ts

@@ -1,5 +1,12 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
+import packageJson from "../../package.json";
+import {
+  MCP_EXPAND_TOOL_DESCRIPTION,
+  MCP_FIND_RELATED_TOOL_DESCRIPTION,
+  MCP_SEARCH_TOOL_DESCRIPTION,
+  MCP_SERVER_INSTRUCTIONS,
+} from "../installer/search-policy.ts";
 import type { ContentType } from "../types.ts";
 import {
   clampMcpTopK,
@@ -12,12 +19,6 @@ import {
   MAX_MCP_TOP_K,
   resolveChunk,
 } from "../utils.ts";
-import {
-  MCP_EXPAND_TOOL_DESCRIPTION,
-  MCP_FIND_RELATED_TOOL_DESCRIPTION,
-  MCP_SEARCH_TOOL_DESCRIPTION,
-  MCP_SERVER_INSTRUCTIONS,
-} from "../installer/search-policy.ts";
 import { getIndexForRepo, type IndexCache, toolText } from "./index-cache.ts";
 
 const REPO_DESCRIPTION =
@@ -29,7 +30,7 @@ export function createMcpServer(cache: IndexCache): McpServer {
   const server = new McpServer(
     {
       name: "miru",
-      version: "0.1.0",
+      version: packageJson.version,
     },
     {
       instructions: MCP_SERVER_INSTRUCTIONS,
@@ -39,8 +40,7 @@ export function createMcpServer(cache: IndexCache): McpServer {
   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 \`repo\` on first call; later calls reuse the session cache.`,
       inputSchema: {
         query: z.string().describe("Natural language or code query."),
         repo: z.string().describe(REPO_DESCRIPTION),
@@ -86,7 +86,9 @@ export function createMcpServer(cache: IndexCache): McpServer {
         line: z
           .number()
           .int()
-          .describe("Line from the hit: `anchor_line` when truncated, otherwise `start_line` (1-indexed)."),
+          .describe(
+            "Line from the hit: `anchor_line` when truncated, otherwise `start_line` (1-indexed).",
+          ),
         repo: z.string().describe(REPO_DESCRIPTION),
         before: z
           .number()
@@ -143,13 +145,13 @@ export function createMcpServer(cache: IndexCache): McpServer {
       inputSchema: {
         file_path: z
           .string()
-          .describe(
-            "Path from a search hit (`file_path` or `absolute_path` for local repos).",
-          ),
+          .describe("Path from a search hit (`file_path` or `absolute_path` for local repos)."),
         line: z
           .number()
           .int()
-          .describe("Line from the hit: `anchor_line` when truncated, otherwise `start_line` (1-indexed)."),
+          .describe(
+            "Line from the hit: `anchor_line` when truncated, otherwise `start_line` (1-indexed).",
+          ),
         repo: z.string().describe(REPO_DESCRIPTION),
         top_k: z
           .number()
@@ -157,7 +159,9 @@ export function createMcpServer(cache: IndexCache): McpServer {
           .min(1)
           .max(MAX_MCP_TOP_K)
           .optional()
-          .describe(`Number of similar chunks to return (default ${DEFAULT_MCP_TOP_K}, max ${MAX_MCP_TOP_K}).`),
+          .describe(
+            `Number of similar chunks to return (default ${DEFAULT_MCP_TOP_K}, max ${MAX_MCP_TOP_K}).`,
+          ),
       },
     },
     async ({ file_path: filePath, line, repo, top_k: topK }) => {

package/src/ranking/location.ts

@@ -172,10 +172,7 @@ export function penalizeInstallerForLocation(
   }
 }
 
-function hasSpecificImplementationTarget(
-  query: string,
-  chunksByKey: Map<string, Chunk>,
-): boolean {
+function hasSpecificImplementationTarget(query: string, chunksByKey: Map<string, Chunk>): boolean {
   const lowered = query.toLowerCase();
   for (const hint of IMPLEMENTATION_HINTS) {
     if (!lowered.includes(hint)) {
@@ -234,7 +231,6 @@ export function boostExactStemMatches(
       }
       const parts = keyword.split("-").filter((p) => p.length > 2);
       if (parts.length > 1 && parts.some((p) => p === stem)) {
-        continue;
       }
     }
   }

package/src/setup.ts

@@ -63,7 +63,7 @@ export async function runSetup(options: RunSetupOptions = {}): Promise<string> {
     spinner.start();
     const result = await validateEmbeddingApiKey({ apiKey });
     if (!result.valid) {
-      spinner.fail(result.message);
+      spinner.stop();
       throw new Error(result.message);
     }
     spinner.succeed("API key validated");

package/src/spinner.ts

@@ -57,7 +57,7 @@ export async function withSpinner<T>(
     spinner.succeed(options?.successMessage ?? "");
     return result;
   } catch (err) {
-    spinner.fail(options?.failMessage);
+    spinner.stop();
     throw err;
   }
 }

package/src/utils.ts

@@ -17,11 +17,22 @@ export function isGitUrl(path: string): boolean {
   return GIT_URL_SCHEMES.some((scheme) => path.startsWith(scheme)) || SCP_GIT_URL_RE.test(path);
 }
 
+export function httpGitCloneAllowed(): boolean {
+  const raw = process.env.MIRU_ALLOW_HTTP_GIT;
+  return raw === "1" || raw === "true";
+}
+
 export function isAllowedRepoSource(repo: string): boolean {
   if (!isGitUrl(repo)) {
     return true;
   }
-  return repo.startsWith("https://") || repo.startsWith("http://");
+  if (repo.startsWith("https://")) {
+    return true;
+  }
+  if (repo.startsWith("http://")) {
+    return httpGitCloneAllowed();
+  }
+  return false;
 }
 
 /** Resolved local repo root for MCP output; null for remote git URLs. */
@@ -29,6 +40,20 @@ export function localRepoRoot(repo: string): string | null {
   return isGitUrl(repo) ? null : resolve(repo);
 }
 
+/** When MIRU_WORKSPACE_ROOT is set, local repo paths must stay inside it. */
+export function validateLocalRepoPath(repo: string): void {
+  const workspaceRoot = process.env.MIRU_WORKSPACE_ROOT?.trim();
+  if (!workspaceRoot || isGitUrl(repo)) {
+    return;
+  }
+  const resolvedRepo = resolve(repo);
+  const resolvedWorkspace = resolve(workspaceRoot);
+  const prefix = resolvedWorkspace.endsWith(sep) ? resolvedWorkspace : `${resolvedWorkspace}${sep}`;
+  if (resolvedRepo !== resolvedWorkspace && !resolvedRepo.startsWith(prefix)) {
+    throw new Error(`Local repo path is outside workspace: ${repo}`);
+  }
+}
+
 /** Map an absolute or repo-relative path to the index-relative form. */
 export function toIndexedFilePath(filePath: string, repoRoot?: string | null): string {
   if (!repoRoot) {
@@ -155,6 +180,15 @@ export function expandChunksAtLine(
   return { anchor, chunks: fileChunks.slice(start, end) };
 }
 
+/** Relative relevance for MCP/CLI output (top hit in a batch is always 100%). */
+export function formatRelevanceScore(score: number, maxScore: number): string {
+  if (maxScore <= 0) {
+    return "0%";
+  }
+  const pct = Math.round((score / maxScore) * 100);
+  return `${pct}%`;
+}
+
 export function formatResults(
   query: string,
   results: SearchResult[],
@@ -163,6 +197,7 @@ export function formatResults(
   const repoRoot = options?.repoRoot ?? null;
   const useSnippet = options?.snippet ?? searchSnippetsEnabled();
   const payload = useSnippet ? applySnippetsToResults(results, query) : null;
+  const maxScore = results.reduce((max, result) => Math.max(max, result.score), 0);
 
   return {
     query,
@@ -170,6 +205,7 @@ export function formatResults(
       const entry = payload?.[index];
       const chunk = entry?.result.chunk ?? result.chunk;
       const dict = chunkToResponseDict(chunk, repoRoot);
+      const score = formatRelevanceScore(result.score, maxScore);
       if (entry?.meta.truncated) {
         return {
           chunk: {
@@ -179,12 +215,12 @@ export function formatResults(
             full_start_line: entry.meta.full_start_line,
             full_end_line: entry.meta.full_end_line,
           },
-          score: result.score,
+          score,
         };
       }
       return {
         chunk: dict,
-        score: result.score,
+        score,
       };
     }),
   };