lens-engine 0.1.19 → 0.1.21

package/daemon.js

@@ -6627,9 +6627,9 @@ var init_handler = __esm({
         if (this.fsw.closed) {
           return;
         }
-        const dirname5 = sysPath.dirname(file);
+        const dirname4 = sysPath.dirname(file);
         const basename4 = sysPath.basename(file);
-        const parent = this.fsw._getWatchedDir(dirname5);
+        const parent = this.fsw._getWatchedDir(dirname4);
         let prevStats = stats;
         if (parent.has(basename4))
           return;
@@ -6656,7 +6656,7 @@ var init_handler = __esm({
                 prevStats = newStats2;
               }
             } catch (error3) {
-              this.fsw._remove(dirname5, basename4);
+              this.fsw._remove(dirname4, basename4);
             }
           } else if (parent.has(basename4)) {
             const at = newStats.atimeMs;
@@ -7605,6 +7605,7 @@ var init_esm2 = __esm({
 var dist_exports = {};
 __export(dist_exports, {
   DEFAULT_CHUNKING_PARAMS: () => DEFAULT_CHUNKING_PARAMS,
+  GOLD_DATASET: () => GOLD_DATASET,
   RequestTrace: () => RequestTrace,
   agglomerativeCluster: () => agglomerativeCluster,
   analyzeGitHistory: () => analyzeGitHistory,
@@ -7616,10 +7617,12 @@ __export(dist_exports, {
   closeDb: () => closeDb,
   cochangeQueries: () => cochangeQueries,
   computeMaxImportDepth: () => computeMaxImportDepth,
-  cosine: () => cosine,
+  computeMetrics: () => computeMetrics,
+  cosine: () => cosine2,
   deriveIdentityKey: () => deriveIdentityKey,
   detectLanguage: () => detectLanguage,
   diffScan: () => diffScan,
+  discoverTestFiles: () => discoverTestFiles,
   enrichPurpose: () => enrichPurpose,
   ensureEmbedded: () => ensureEmbedded,
   ensureIndexed: () => ensureIndexed,
@@ -7654,10 +7657,13 @@ __export(dist_exports, {
   metadataQueries: () => metadataQueries,
   openDb: () => openDb,
   parseGitLog: () => parseGitLog,
+  parseQuery: () => parseQuery,
   registerRepo: () => registerRepo,
   removeRepo: () => removeRepo,
   repoQueries: () => repoQueries,
   resolveImport: () => resolveImport,
+  resolveSnippets: () => resolveSnippets,
+  runEval: () => runEval,
   runIndex: () => runIndex,
   setTelemetryEnabled: () => setTelemetryEnabled,
   settingsQueries: () => settingsQueries,
@@ -7670,21 +7676,21 @@ __export(dist_exports, {
   vectorSearch: () => vectorSearch
 });
 import { randomUUID } from "crypto";
-import Database from "better-sqlite3";
-import { existsSync, mkdirSync } from "fs";
-import { join as join3 } from "path";
-import { homedir } from "os";
+import { readFile } from "fs/promises";
 import { createHash } from "crypto";
 import { execFile } from "child_process";
 import { stat as stat4 } from "fs/promises";
-import { resolve as resolve3, extname as extname2 } from "path";
+import { extname as extname2, resolve as resolve3 } from "path";
 import { promisify } from "util";
-import { readFile } from "fs/promises";
-import { createHash as createHash2 } from "crypto";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
+import Database from "better-sqlite3";
 import { readFile as readFile2, stat as stat22 } from "fs/promises";
 import { relative as relative3 } from "path";
+import { createHash as createHash2 } from "crypto";
 function jsonParse(val, fallback) {
   if (val == null) return fallback;
   if (typeof val === "string") {
@@ -7704,339 +7710,75 @@ function fromEmbeddingBlob(blob2) {
   const buf = blob2 instanceof Buffer ? blob2 : Buffer.from(blob2);
   return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
 }
-function resolveDbPath(customPath) {
-  if (customPath) return customPath;
-  const dir = join3(homedir(), ".lens");
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  return join3(dir, "data.db");
-}
-function openDb(customPath) {
-  if (_db) return _db;
-  const dbPath = resolveDbPath(customPath);
-  const sqlite = new Database(dbPath);
-  sqlite.pragma("journal_mode = WAL");
-  sqlite.pragma("busy_timeout = 5000");
-  sqlite.pragma("foreign_keys = ON");
-  const db = drizzle(sqlite, { schema: schema_exports });
-  sqlite.exec(createTablesSql());
-  const cols = new Set(
-    sqlite.pragma("table_info(file_metadata)").map((c) => c.name)
-  );
-  if (!cols.has("sections")) sqlite.exec("ALTER TABLE file_metadata ADD COLUMN sections TEXT DEFAULT '[]'");
-  if (!cols.has("internals")) sqlite.exec("ALTER TABLE file_metadata ADD COLUMN internals TEXT DEFAULT '[]'");
-  const repoCols = new Set(
-    sqlite.pragma("table_info(repos)").map((c) => c.name)
-  );
-  if (!repoCols.has("enable_embeddings")) sqlite.exec("ALTER TABLE repos ADD COLUMN enable_embeddings INTEGER NOT NULL DEFAULT 1");
-  if (!repoCols.has("enable_summaries")) sqlite.exec("ALTER TABLE repos ADD COLUMN enable_summaries INTEGER NOT NULL DEFAULT 1");
-  if (!repoCols.has("enable_vocab_clusters")) sqlite.exec("ALTER TABLE repos ADD COLUMN enable_vocab_clusters INTEGER NOT NULL DEFAULT 1");
-  if (!repoCols.has("last_vocab_cluster_commit")) sqlite.exec("ALTER TABLE repos ADD COLUMN last_vocab_cluster_commit TEXT");
-  const logCols = new Set(
-    sqlite.pragma("table_info(request_logs)").map((c) => c.name)
-  );
-  if (!logCols.has("response_body")) sqlite.exec("ALTER TABLE request_logs ADD COLUMN response_body TEXT");
-  if (!logCols.has("trace")) sqlite.exec("ALTER TABLE request_logs ADD COLUMN trace TEXT");
-  _db = db;
-  _raw = sqlite;
-  return db;
-}
-function getDb() {
-  if (!_db) throw new Error("Database not initialized. Call openDb() first.");
-  return _db;
-}
-function getRawDb() {
-  if (!_raw) throw new Error("Database not initialized. Call openDb() first.");
-  return _raw;
-}
-function closeDb() {
-  if (_raw) _raw.close();
-  _db = null;
-  _raw = null;
-}
-function createTablesSql() {
-  return `
-    CREATE TABLE IF NOT EXISTS repos (
-      id TEXT PRIMARY KEY,
-      identity_key TEXT UNIQUE NOT NULL,
-      name TEXT NOT NULL,
-      root_path TEXT NOT NULL,
-      remote_url TEXT,
-      last_indexed_commit TEXT,
-      index_status TEXT NOT NULL DEFAULT 'pending',
-      last_indexed_at TEXT,
-      last_git_analysis_commit TEXT,
-      max_import_depth INTEGER DEFAULT 0,
-      vocab_clusters TEXT,
-      last_vocab_cluster_commit TEXT,
-      enable_embeddings INTEGER NOT NULL DEFAULT 1,
-      enable_summaries INTEGER NOT NULL DEFAULT 1,
-      enable_vocab_clusters INTEGER NOT NULL DEFAULT 1,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_repos_identity ON repos(identity_key);
-
-    CREATE TABLE IF NOT EXISTS chunks (
-      id TEXT PRIMARY KEY,
-      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
-      path TEXT NOT NULL,
-      chunk_index INTEGER NOT NULL,
-      start_line INTEGER NOT NULL,
-      end_line INTEGER NOT NULL,
-      content TEXT NOT NULL,
-      chunk_hash TEXT NOT NULL,
-      last_seen_commit TEXT NOT NULL,
-      language TEXT,
-      embedding BLOB,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-      UNIQUE(repo_id, path, chunk_index, chunk_hash)
-    );
-    CREATE INDEX IF NOT EXISTS idx_chunks_repo_path ON chunks(repo_id, path);
-    CREATE INDEX IF NOT EXISTS idx_chunks_repo ON chunks(repo_id);
-    CREATE INDEX IF NOT EXISTS idx_chunks_hash ON chunks(repo_id, chunk_hash);
-
-    CREATE TABLE IF NOT EXISTS file_metadata (
-      id TEXT PRIMARY KEY,
-      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
-      path TEXT NOT NULL,
-      language TEXT,
-      exports TEXT DEFAULT '[]',
-      imports TEXT DEFAULT '[]',
-      docstring TEXT DEFAULT '',
-      sections TEXT DEFAULT '[]',
-      internals TEXT DEFAULT '[]',
-      purpose TEXT DEFAULT '',
-      purpose_hash TEXT DEFAULT '',
-      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-      UNIQUE(repo_id, path)
-    );
-    CREATE INDEX IF NOT EXISTS idx_file_metadata_repo ON file_metadata(repo_id);
-
-    CREATE TABLE IF NOT EXISTS file_imports (
-      id TEXT PRIMARY KEY,
-      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
-      source_path TEXT NOT NULL,
-      target_path TEXT NOT NULL,
-      UNIQUE(repo_id, source_path, target_path)
-    );
-    CREATE INDEX IF NOT EXISTS idx_file_imports_target ON file_imports(repo_id, target_path);
-
-    CREATE TABLE IF NOT EXISTS file_stats (
-      id TEXT PRIMARY KEY,
-      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
-      path TEXT NOT NULL,
-      commit_count INTEGER NOT NULL DEFAULT 0,
-      recent_count INTEGER NOT NULL DEFAULT 0,
-      last_modified TEXT,
-      UNIQUE(repo_id, path)
-    );
-
-    CREATE TABLE IF NOT EXISTS file_cochanges (
-      id TEXT PRIMARY KEY,
-      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
-      path_a TEXT NOT NULL,
-      path_b TEXT NOT NULL,
-      cochange_count INTEGER NOT NULL DEFAULT 1,
-      UNIQUE(repo_id, path_a, path_b)
-    );
-    CREATE INDEX IF NOT EXISTS idx_cochanges_lookup ON file_cochanges(repo_id, path_a);
-
-    CREATE TABLE IF NOT EXISTS usage_counters (
-      id TEXT PRIMARY KEY,
-      date TEXT NOT NULL UNIQUE,
-      context_queries INTEGER NOT NULL DEFAULT 0,
-      embedding_requests INTEGER NOT NULL DEFAULT 0,
-      embedding_chunks INTEGER NOT NULL DEFAULT 0,
-      purpose_requests INTEGER NOT NULL DEFAULT 0,
-      repos_indexed INTEGER NOT NULL DEFAULT 0,
-      synced_at TEXT,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_usage_counters_date ON usage_counters(date);
-
-    CREATE TABLE IF NOT EXISTS request_logs (
-      id TEXT PRIMARY KEY,
-      method TEXT NOT NULL,
-      path TEXT NOT NULL,
-      status INTEGER NOT NULL,
-      duration_ms INTEGER NOT NULL,
-      source TEXT NOT NULL DEFAULT 'api',
-      request_body TEXT,
-      response_size INTEGER,
-      response_body TEXT,
-      trace TEXT,
-      created_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_request_logs_created ON request_logs(created_at);
-    CREATE INDEX IF NOT EXISTS idx_request_logs_source ON request_logs(source);
-
-    CREATE TABLE IF NOT EXISTS settings (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL,
-      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-
-    CREATE TABLE IF NOT EXISTS telemetry_events (
-      id TEXT PRIMARY KEY,
-      event_type TEXT NOT NULL,
-      event_data TEXT,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      synced_at TEXT
-    );
-    CREATE INDEX IF NOT EXISTS idx_telemetry_events_type ON telemetry_events(event_type);
-    CREATE INDEX IF NOT EXISTS idx_telemetry_events_synced ON telemetry_events(synced_at);
-  `;
+function extractSlice(chunks2, targetLine) {
+  const chunk = chunks2.find((c) => c.start_line <= targetLine && targetLine <= c.end_line);
+  if (!chunk) return null;
+  const lines = chunk.content.split("\n");
+  const offset = targetLine - chunk.start_line;
+  const from = Math.max(0, offset - RADIUS);
+  const to = Math.min(lines.length, offset + RADIUS + 1);
+  const sliced = lines.slice(from, to);
+  if (!sliced.length) return null;
+  return {
+    startLine: chunk.start_line + from,
+    endLine: chunk.start_line + to - 1,
+    code: sliced.join("\n")
+  };
 }
-function normalizeRemoteUrl(url) {
-  let normalized = url.trim();
-  const sshMatch = normalized.match(/^[\w-]+@([\w.-]+):(.+)$/);
-  if (sshMatch) {
-    normalized = `${sshMatch[1]}/${sshMatch[2]}`;
-  } else {
-    normalized = normalized.replace(/^https?:\/\//, "");
+function sliceContext(db, repoId, snippets, queryKind) {
+  const result = /* @__PURE__ */ new Map();
+  const limit = MAX_SLICES[queryKind] ?? 3;
+  const candidates = [...snippets.values()].filter((s) => s.line !== null).slice(0, limit);
+  if (!candidates.length) return result;
+  const paths = candidates.map((c) => c.path);
+  const allChunks = chunkQueries.getByRepoPaths(db, repoId, paths);
+  const chunksByPath = /* @__PURE__ */ new Map();
+  for (const c of allChunks) {
+    const arr = chunksByPath.get(c.path) ?? [];
+    arr.push({ start_line: c.start_line, end_line: c.end_line, content: c.content });
+    chunksByPath.set(c.path, arr);
+  }
+  for (const snip of candidates) {
+    const chunks2 = chunksByPath.get(snip.path);
+    if (!chunks2) continue;
+    const slice = extractSlice(chunks2, snip.line);
+    if (!slice) continue;
+    result.set(snip.path, {
+      path: snip.path,
+      startLine: slice.startLine,
+      endLine: slice.endLine,
+      code: slice.code,
+      symbol: snip.symbol
+    });
   }
-  normalized = normalized.replace(/\.git$/, "");
-  normalized = normalized.replace(/\/$/, "");
-  return normalized.toLowerCase();
-}
-function deriveIdentityKey(rootPath, remoteUrl) {
-  const source = remoteUrl ? normalizeRemoteUrl(remoteUrl) : rootPath;
-  return createHash("sha256").update(source).digest("hex");
+  return result;
 }
-function isDocFile(filePath) {
-  return DOCS_EXTENSIONS.has(extname2(filePath).toLowerCase());
+function setTelemetryEnabled(enabled) {
+  _enabled = enabled;
 }
-function detectLanguage(filePath) {
-  return LANG_MAP[extname2(filePath).toLowerCase()] ?? null;
+function track(db, eventType, data) {
+  if (!_enabled) return;
+  try {
+    telemetryQueries.insert(db, eventType, data);
+  } catch {
+  }
 }
-function isBinaryExt(filePath) {
-  return BINARY_EXTENSIONS.has(extname2(filePath).toLowerCase());
+function computeChunkHash(content, params) {
+  const payload = JSON.stringify({ content, params });
+  return createHash("sha256").update(payload).digest("hex");
 }
-async function fullScan(repoRoot) {
-  const { stdout } = await execFileAsync("git", ["ls-files", "-z"], { cwd: repoRoot, maxBuffer: 50 * 1024 * 1024 });
-  const paths = stdout.split("\0").filter(Boolean);
-  const results = [];
-  for (const p of paths) {
-    if (isBinaryExt(p)) continue;
-    const abs = resolve3(repoRoot, p);
-    try {
-      const s = await stat4(abs);
-      if (s.size > MAX_FILE_SIZE) continue;
-    } catch {
-      continue;
-    }
-    results.push({ path: p, absolute_path: abs, language: detectLanguage(p), status: "added" });
-  }
-  return results;
-}
-async function diffScan(repoRoot, fromCommit, toCommit) {
-  const { stdout } = await execFileAsync(
-    "git",
-    ["diff", "--name-status", "--diff-filter=ACMRD", "-z", `${fromCommit}..${toCommit}`],
-    { cwd: repoRoot, maxBuffer: 50 * 1024 * 1024 }
-  );
-  const parts = stdout.split("\0").filter(Boolean);
-  const results = [];
-  for (let i = 0; i < parts.length; i += 2) {
-    const statusChar = parts[i];
-    const p = parts[i + 1];
-    if (!p) continue;
-    if (isBinaryExt(p)) continue;
-    const abs = resolve3(repoRoot, p);
-    let status;
-    if (statusChar === "D") {
-      status = "deleted";
-    } else if (statusChar === "A") {
-      status = "added";
-    } else {
-      status = "modified";
-    }
-    if (status !== "deleted") {
-      try {
-        const s = await stat4(abs);
-        if (s.size > MAX_FILE_SIZE) continue;
-      } catch {
-        continue;
-      }
-    }
-    results.push({ path: p, absolute_path: abs, language: detectLanguage(p), status });
-  }
-  return results;
-}
-async function getHeadCommit(repoRoot) {
-  const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: repoRoot });
-  return stdout.trim();
-}
-function registerRepo(db, rootPath, name, remoteUrl) {
-  const identityKey = deriveIdentityKey(rootPath, remoteUrl);
-  const repoName = name ?? rootPath.split("/").pop() ?? "unknown";
-  const { id, created } = repoQueries.upsert(db, identityKey, repoName, rootPath, remoteUrl ?? null);
-  return { repo_id: id, identity_key: identityKey, name: repoName, created };
-}
-function getRepo(db, id) {
-  const repo = repoQueries.getById(db, id);
-  if (!repo) throw new Error("repo not found");
-  return repo;
-}
-function listRepos(db) {
-  return repoQueries.list(db);
-}
-function removeRepo(db, id) {
-  const chunkCount = chunkQueries.countByRepo(db, id);
-  const deleted = repoQueries.remove(db, id);
-  if (!deleted) throw new Error("repo not found");
-  return { deleted: true, chunks_removed: chunkCount };
-}
-async function getRepoStatus(db, id) {
-  const repo = repoQueries.getById(db, id);
-  if (!repo) throw new Error("repo not found");
-  let currentHead = null;
-  try {
-    currentHead = await getHeadCommit(repo.root_path);
-  } catch {
-  }
-  const isStale = !!(currentHead && repo.last_indexed_commit !== currentHead);
-  const stats = chunkQueries.getStats(db, id);
-  const structural = metadataQueries.getStructuralStats(db, id);
-  const vocabRaw = repo.vocab_clusters;
-  const vocabClusters = vocabRaw ? JSON.parse(vocabRaw) : [];
-  return {
-    index_status: repo.index_status,
-    indexed_commit: repo.last_indexed_commit,
-    current_head: currentHead,
-    is_stale: isStale,
-    chunk_count: stats.chunk_count,
-    files_indexed: stats.files_indexed,
-    embedded_count: stats.embedded_count,
-    embeddable_count: stats.embeddable_count,
-    embedded_pct: stats.embeddable_count > 0 ? Math.round(stats.embedded_count / stats.embeddable_count * 100) : 0,
-    metadata_count: structural.metadata_count,
-    import_edge_count: structural.import_edge_count,
-    git_commits_analyzed: structural.git_file_count,
-    cochange_pairs: structural.cochange_pairs,
-    purpose_count: structural.purpose_count,
-    purpose_total: structural.purpose_total,
-    vocab_cluster_count: Array.isArray(vocabClusters) ? vocabClusters.length : 0
-  };
-}
-function computeChunkHash(content, params) {
-  const payload = JSON.stringify({ content, params });
-  return createHash2("sha256").update(payload).digest("hex");
-}
-function findBoundary(lines, targetLine, windowSize = 15) {
-  const start = Math.max(0, targetLine - windowSize);
-  const end = Math.min(lines.length, targetLine + windowSize);
-  let bestBlank = -1;
-  let bestBlankDist = Infinity;
-  for (let i = start; i < end; i++) {
-    if (lines[i].trim() === "") {
-      const dist = Math.abs(i - targetLine);
-      if (dist < bestBlankDist) {
-        bestBlank = i;
-        bestBlankDist = dist;
-      }
+function findBoundary(lines, targetLine, windowSize = 15) {
+  const start = Math.max(0, targetLine - windowSize);
+  const end = Math.min(lines.length, targetLine + windowSize);
+  let bestBlank = -1;
+  let bestBlankDist = Infinity;
+  for (let i = start; i < end; i++) {
+    if (lines[i].trim() === "") {
+      const dist = Math.abs(i - targetLine);
+      if (dist < bestBlankDist) {
+        bestBlank = i;
+        bestBlankDist = dist;
+      }
     }
   }
   if (bestBlank >= 0) return bestBlank + 1;
@@ -8093,6 +7835,70 @@ function chunkFile(content, params = DEFAULT_CHUNKING_PARAMS) {
   }
   return chunks2;
 }
+function isDocFile(filePath) {
+  return DOCS_EXTENSIONS.has(extname2(filePath).toLowerCase());
+}
+function detectLanguage(filePath) {
+  return LANG_MAP[extname2(filePath).toLowerCase()] ?? null;
+}
+function isBinaryExt(filePath) {
+  return BINARY_EXTENSIONS.has(extname2(filePath).toLowerCase());
+}
+async function fullScan(repoRoot) {
+  const { stdout } = await execFileAsync("git", ["ls-files", "-z"], { cwd: repoRoot, maxBuffer: 50 * 1024 * 1024 });
+  const paths = stdout.split("\0").filter(Boolean);
+  const results = [];
+  for (const p of paths) {
+    if (isBinaryExt(p)) continue;
+    const abs = resolve3(repoRoot, p);
+    try {
+      const s = await stat4(abs);
+      if (s.size > MAX_FILE_SIZE) continue;
+    } catch {
+      continue;
+    }
+    results.push({ path: p, absolute_path: abs, language: detectLanguage(p), status: "added" });
+  }
+  return results;
+}
+async function diffScan(repoRoot, fromCommit, toCommit) {
+  const { stdout } = await execFileAsync(
+    "git",
+    ["diff", "--name-status", "--diff-filter=ACMRD", "-z", `${fromCommit}..${toCommit}`],
+    { cwd: repoRoot, maxBuffer: 50 * 1024 * 1024 }
+  );
+  const parts = stdout.split("\0").filter(Boolean);
+  const results = [];
+  for (let i = 0; i < parts.length; i += 2) {
+    const statusChar = parts[i];
+    const p = parts[i + 1];
+    if (!p) continue;
+    if (isBinaryExt(p)) continue;
+    const abs = resolve3(repoRoot, p);
+    let status;
+    if (statusChar === "D") {
+      status = "deleted";
+    } else if (statusChar === "A") {
+      status = "added";
+    } else {
+      status = "modified";
+    }
+    if (status !== "deleted") {
+      try {
+        const s = await stat4(abs);
+        if (s.size > MAX_FILE_SIZE) continue;
+      } catch {
+        continue;
+      }
+    }
+    results.push({ path: p, absolute_path: abs, language: detectLanguage(p), status });
+  }
+  return results;
+}
+async function getHeadCommit(repoRoot) {
+  const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: repoRoot });
+  return stdout.trim();
+}
 function extractImportSpecifiers(content, language) {
   switch (language) {
     case "typescript":
@@ -8195,13 +8001,13 @@ function resolveRust(dir, spec, known) {
     base = spec.replace("crate::", "src/").replace(/::/g, "/");
   } else if (spec.startsWith("super::")) {
     const parent = dir.substring(0, dir.lastIndexOf("/"));
-    base = parent + "/" + spec.replace("super::", "").replace(/::/g, "/");
+    base = `${parent}/${spec.replace("super::", "").replace(/::/g, "/")}`;
   } else {
-    base = dir + "/" + spec.replace("self::", "").replace(/::/g, "/");
+    base = `${dir}/${spec.replace("self::", "").replace(/::/g, "/")}`;
   }
-  const candidate = normalizePath2(base) + ".rs";
+  const candidate = `${normalizePath2(base)}.rs`;
   if (known.has(candidate)) return candidate;
-  const modCandidate = normalizePath2(base) + "/mod.rs";
+  const modCandidate = `${normalizePath2(base)}/mod.rs`;
   if (known.has(modCandidate)) return modCandidate;
   return null;
 }
@@ -8349,7 +8155,8 @@ function extractAndPersistMetadata(db, repoId) {
   for (const row of rows) {
     const existing = files.get(row.path);
     if (existing) {
-      existing.content += "\n" + row.content;
+      existing.content += `
+${row.content}`;
     } else {
       files.set(row.path, {
         content: row.content,
@@ -8375,35 +8182,6 @@ function extractAndPersistMetadata(db, repoId) {
   }
   return count;
 }
-function buildAndPersistImportGraph(db, repoId) {
-  const rows = chunkQueries.getAllByRepo(db, repoId);
-  const files = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const existing = files.get(row.path);
-    if (existing) {
-      existing.content += "\n" + row.content;
-    } else {
-      files.set(row.path, {
-        content: row.content,
-        language: row.language ?? detectLanguage(row.path) ?? "text"
-      });
-    }
-  }
-  const knownPaths = new Set(files.keys());
-  importQueries.deleteByRepo(db, repoId);
-  let edgeCount = 0;
-  for (const [sourcePath, { content, language }] of files) {
-    const specs = extractImportSpecifiers(content, language);
-    for (const spec of specs) {
-      const targetPath = resolveImport(sourcePath, spec, language, knownPaths);
-      if (targetPath && targetPath !== sourcePath) {
-        importQueries.insert(db, repoId, sourcePath, targetPath);
-        edgeCount++;
-      }
-    }
-  }
-  return edgeCount;
-}
 async function analyzeGitHistory(db, repoId, rootPath, lastAnalyzedCommit) {
   const args = ["log", "--name-only", "--format=%H %aI", "--no-merges", `-n`, `${MAX_COMMITS}`];
   if (lastAnalyzedCommit) args.push(`${lastAnalyzedCommit}..HEAD`);
@@ -8498,15 +8276,35 @@ function parseGitLog(stdout) {
   if (current) commits.push(current);
   return commits;
 }
-function setTelemetryEnabled(enabled) {
-  _enabled = enabled;
-}
-function track(db, eventType, data) {
-  if (!_enabled) return;
-  try {
-    telemetryQueries.insert(db, eventType, data);
-  } catch {
+function buildAndPersistImportGraph(db, repoId) {
+  const rows = chunkQueries.getAllByRepo(db, repoId);
+  const files = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const existing = files.get(row.path);
+    if (existing) {
+      existing.content += `
+${row.content}`;
+    } else {
+      files.set(row.path, {
+        content: row.content,
+        language: row.language ?? detectLanguage(row.path) ?? "text"
+      });
+    }
+  }
+  const knownPaths = new Set(files.keys());
+  importQueries.deleteByRepo(db, repoId);
+  let edgeCount = 0;
+  for (const [sourcePath, { content, language }] of files) {
+    const specs = extractImportSpecifiers(content, language);
+    for (const spec of specs) {
+      const targetPath = resolveImport(sourcePath, spec, language, knownPaths);
+      if (targetPath && targetPath !== sourcePath) {
+        importQueries.insert(db, repoId, sourcePath, targetPath);
+        edgeCount++;
+      }
+    }
   }
+  return edgeCount;
 }
 async function withLock(key, fn) {
   while (locks.has(key)) {
@@ -8524,7 +8322,7 @@ async function withLock(key, fn) {
     resolve22();
   }
 }
-async function runIndex(db, repoId, caps, force = false, onProgress, trace) {
+async function runIndex(db, repoId, _caps, force = false, onProgress, trace) {
   return withLock(repoId, async () => {
     const start = Date.now();
     const repo = repoQueries.getById(db, repoId);
@@ -8696,458 +8494,372 @@ async function ensureIndexed(db, repoId, caps) {
   if (repo.last_indexed_commit === head) return null;
   return runIndex(db, repoId, caps);
 }
-function estimateTokens(text22) {
-  return Math.ceil(text22.length / CHARS_PER_TOKEN);
+function estimateTokens(s) {
+  return Math.ceil(s.length / 4);
 }
-async function ensureEmbedded(db, repoId, caps) {
-  const start = Date.now();
-  if (!caps?.embedTexts) {
-    return { embedded_count: 0, skipped_count: 0, duration_ms: 0 };
+function basename3(p) {
+  const i = p.lastIndexOf("/");
+  return i >= 0 ? p.substring(i + 1) : p;
+}
+function guessLang(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot < 0) return "";
+  return LANG_EXT[path.substring(dot + 1)] ?? "";
+}
+function getPurpose(path, data) {
+  for (const m of data.metadata) {
+    if (m.path === path && m.purpose) return m.purpose;
   }
-  let embedded = 0;
-  let apiCalls = 0;
-  while (apiCalls < MAX_API_CALLS) {
-    const remaining = chunkQueries.countUnembedded(db, repoId);
-    if (remaining === 0) break;
-    const rows = chunkQueries.getUnembedded(db, repoId, POOL_SIZE);
-    if (rows.length === 0) break;
-    const validRows = rows.filter((r) => r.content.trim().length > 0);
-    if (validRows.length === 0) {
-      apiCalls++;
-      continue;
-    }
-    let offset = 0;
-    let poolFailed = false;
-    while (offset < validRows.length && apiCalls < MAX_API_CALLS) {
-      const batch = [];
-      let batchTokens = 0;
-      while (offset < validRows.length) {
-        const est = estimateTokens(validRows[offset].content);
-        if (batch.length > 0 && batchTokens + est > MAX_BATCH_TOKENS) break;
-        batch.push(validRows[offset]);
-        batchTokens += est;
-        offset++;
-      }
-      try {
-        const texts = batch.map((r) => r.content);
-        const vectors = await caps.embedTexts(texts);
-        for (let i = 0; i < batch.length; i++) {
-          chunkQueries.updateEmbedding(db, batch[i].id, repoId, vectors[i]);
-        }
-        embedded += batch.length;
-      } catch (err) {
-        console.error(`[LENS] Embed batch failed (${batch.length} chunks, ~${batchTokens} tokens):`, err.message);
-        poolFailed = true;
-        break;
-      }
-      apiCalls++;
-    }
-    if (poolFailed) break;
-  }
-  return { embedded_count: embedded, skipped_count: 0, duration_ms: Date.now() - start };
+  return "";
 }
-async function enrichPurpose(db, repoId, caps, fullRun = false) {
-  const start = Date.now();
-  if (!caps?.generatePurpose) {
-    return { enriched: 0, skipped: 0, duration_ms: 0 };
+function renderImports(path, data) {
+  const fwd = data.forwardImports.get(path)?.slice(0, 3) ?? [];
+  const rev = data.reverseImports.get(path)?.slice(0, 3) ?? [];
+  const parts = [];
+  if (rev.length) parts.push(`\u2190 ${rev.join(", ")}`);
+  if (fwd.length) parts.push(`\u2192 ${fwd.join(", ")}`);
+  return parts.join(" | ");
+}
+function renderCochanges(path, cochanges, limit = 2) {
+  const partners = [];
+  for (const cc of cochanges) {
+    if (cc.path === path) partners.push({ name: basename3(cc.partner), count: cc.count });
+    else if (cc.partner === path) partners.push({ name: basename3(cc.path), count: cc.count });
   }
-  let totalEnriched = 0;
-  let totalSkipped = 0;
-  while (true) {
-    const candidates = metadataQueries.getCandidatesForPurpose(db, repoId, PURPOSE_BATCH_LIMIT);
-    if (candidates.length === 0) break;
-    for (let i = 0; i < candidates.length; i += PURPOSE_CONCURRENCY) {
-      const batch = candidates.slice(i, i + PURPOSE_CONCURRENCY);
-      const results = await Promise.allSettled(
-        batch.map(async (row) => {
-          const exports = Array.isArray(row.exports) ? row.exports : jsonParse(row.exports, []);
-          const purpose = await caps.generatePurpose(row.path, row.first_chunk, exports, row.docstring ?? "");
-          return { row, purpose };
-        })
-      );
-      for (let j = 0; j < results.length; j++) {
-        const result = results[j];
-        const row = batch[j];
-        if (result.status === "fulfilled" && result.value.purpose) {
-          metadataQueries.updatePurpose(db, repoId, row.path, result.value.purpose, row.chunk_hash);
-          totalEnriched++;
-        } else {
-          metadataQueries.setPurposeHash(db, repoId, row.path, row.chunk_hash);
-          totalSkipped++;
-        }
-      }
-    }
-    if (!fullRun) break;
+  partners.sort((a, b) => b.count - a.count);
+  return partners.slice(0, limit).map((p) => `${p.name} (${p.count}x)`).join(", ");
+}
+function getExports(path, data) {
+  for (const m of data.metadata) {
+    if (m.path === path) return m.exports ?? [];
   }
-  return { enriched: totalEnriched, skipped: totalSkipped, duration_ms: Date.now() - start };
+  return [];
 }
-function splitIdentifier(name) {
-  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_\-./\\]/g, " ").toLowerCase().split(/\s+/).filter((w) => w.length >= 3 && !STOPWORDS.has(w));
+function fileLabel(path, snippet) {
+  const line = snippet?.line ? `:${snippet.line}` : "";
+  return `${path}${line}`;
 }
-function extractVocab(files) {
-  const termToFiles = /* @__PURE__ */ new Map();
-  for (const f of files) {
-    const pathParts = f.path.split("/");
-    for (const seg of pathParts) {
-      const base = seg.replace(/\.[^.]+$/, "");
-      for (const word of splitIdentifier(base)) {
-        const s = termToFiles.get(word) ?? /* @__PURE__ */ new Set();
-        s.add(f.path);
-        termToFiles.set(word, s);
-      }
-    }
-    for (const exp of f.exports) {
-      for (const word of splitIdentifier(exp)) {
-        const s = termToFiles.get(word) ?? /* @__PURE__ */ new Set();
-        s.add(f.path);
-        termToFiles.set(word, s);
-      }
+function renderSlice(path, data) {
+  const slice = data.slices?.get(path);
+  if (!slice) return null;
+  const lang = guessLang(path);
+  return `   \`\`\`${lang}
+${slice.code}
+   \`\`\``;
+}
+function formatNatural(data) {
+  const L = [];
+  const files = data.files.slice(0, 7);
+  const snippets = data.snippets ?? /* @__PURE__ */ new Map();
+  L.push(`# ${data.goal}`);
+  L.push("");
+  L.push("## Key Files");
+  for (let i = 0; i < files.length; i++) {
+    const f = files[i];
+    const snip = snippets.get(f.path);
+    const purpose = getPurpose(f.path, data);
+    const label = fileLabel(f.path, snip);
+    L.push(`${i + 1}. **${label}**${purpose ? ` \u2014 ${purpose}` : ""}`);
+    const exports = getExports(f.path, data);
+    if (exports.length) L.push(`   Exports: ${exports.slice(0, 5).join(", ")}`);
+    const imports = renderImports(f.path, data);
+    if (imports) L.push(`   ${imports}`);
+    const cochangeStr = renderCochanges(f.path, data.cochanges);
+    if (cochangeStr) L.push(`   Co-changes: ${cochangeStr}`);
+    const sliceStr = renderSlice(f.path, data);
+    if (sliceStr) L.push(sliceStr);
+  }
+  const testLines = [];
+  const testFiles = data.testFiles;
+  if (testFiles) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const f of files.slice(0, 5)) {
+      const tests = testFiles.get(f.path);
+      if (tests) {
+        for (const t of tests) {
+          if (!seen.has(t)) {
+            seen.add(t);
+            testLines.push(`- ${t}`);
+          }
+        }
+      }
+    }
+  }
+  if (testLines.length) {
+    L.push("");
+    L.push("## Tests");
+    for (const t of testLines) L.push(t);
+  }
+  return L.join("\n");
+}
+function formatSymbol(data) {
+  const L = [];
+  const files = data.files;
+  const snippets = data.snippets ?? /* @__PURE__ */ new Map();
+  const top = files[0];
+  if (!top) return `# ${data.goal}
+
+No files found.`;
+  const snip = snippets.get(top.path);
+  const purpose = getPurpose(top.path, data);
+  L.push(`# Symbol: ${data.goal}`);
+  L.push("");
+  L.push("## Definition");
+  L.push(`**${fileLabel(top.path, snip)}**${purpose ? ` \u2014 ${purpose}` : ""}`);
+  if (snip?.symbol) {
+    L.push(`  \`${snip.symbol}\``);
+  } else {
+    const exports = getExports(top.path, data);
+    if (exports.length) L.push(`  Exports: ${exports.slice(0, 5).join(", ")}`);
+  }
+  const sliceStr = renderSlice(top.path, data);
+  if (sliceStr) L.push(sliceStr);
+  const rev = data.reverseImports.get(top.path);
+  if (rev?.length) {
+    L.push("");
+    L.push("## Dependents");
+    L.push(`\u2190 ${rev.slice(0, 5).join(", ")}`);
+  }
+  const cochangeStr = renderCochanges(top.path, data.cochanges, 3);
+  if (cochangeStr) {
+    L.push("");
+    L.push("## Co-changes");
+    L.push(cochangeStr);
+  }
+  if (files.length > 1) {
+    L.push("");
+    L.push("## Also relevant");
+    for (let i = 1; i < Math.min(files.length, 5); i++) {
+      const f = files[i];
+      const p = getPurpose(f.path, data);
+      L.push(`${i + 1}. ${f.path}${p ? ` \u2014 ${p}` : ""}`);
     }
   }
-  const totalFiles = files.length;
-  const maxDf = Math.max(10, Math.floor(totalFiles * 0.3));
-  const filtered = [];
-  for (const [term, fileSet] of termToFiles) {
-    if (fileSet.size >= 2 && fileSet.size <= maxDf) {
-      filtered.push(term);
+  return L.join("\n");
+}
+function formatError(data) {
+  const L = [];
+  const files = data.files;
+  const snippets = data.snippets ?? /* @__PURE__ */ new Map();
+  L.push(`# Error: ${data.goal}`);
+  L.push("");
+  if (files.length === 0) {
+    L.push("No matching files found.");
+    return L.join("\n");
+  }
+  const top = files[0];
+  const snip = snippets.get(top.path);
+  const purpose = getPurpose(top.path, data);
+  L.push("## Error Source");
+  L.push(`1. **${fileLabel(top.path, snip)}**${purpose ? ` \u2014 ${purpose}` : ""}`);
+  const exports = getExports(top.path, data);
+  if (exports.length) L.push(`   Exports: ${exports.slice(0, 5).join(", ")}`);
+  const imports = renderImports(top.path, data);
+  if (imports) L.push(`   ${imports}`);
+  const sliceStr = renderSlice(top.path, data);
+  if (sliceStr) L.push(sliceStr);
+  if (files.length > 1) {
+    L.push("");
+    L.push("## Also References");
+    for (let i = 1; i < Math.min(files.length, 5); i++) {
+      const f = files[i];
+      const s = snippets.get(f.path);
+      const p = getPurpose(f.path, data);
+      L.push(`${i + 1}. **${fileLabel(f.path, s)}**${p ? ` \u2014 ${p}` : ""}`);
     }
   }
-  filtered.sort((a, b) => (termToFiles.get(b)?.size ?? 0) - (termToFiles.get(a)?.size ?? 0));
-  const terms = filtered.slice(0, MAX_TERMS);
-  return { terms, termToFiles };
+  return L.join("\n");
 }
-function cosine(a, b) {
-  let dot = 0, na = 0, nb = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    na += a[i] * a[i];
-    nb += b[i] * b[i];
+function formatStackTrace(data) {
+  const L = [];
+  const files = data.files;
+  const snippets = data.snippets ?? /* @__PURE__ */ new Map();
+  L.push("# Stack Trace");
+  L.push("");
+  if (files.length === 0) {
+    L.push("No matching files found.");
+    return L.join("\n");
+  }
+  const top = files[0];
+  const snip = snippets.get(top.path);
+  const purpose = getPurpose(top.path, data);
+  L.push("## Crash Point");
+  L.push(`**${fileLabel(top.path, snip)}**${purpose ? ` \u2014 ${purpose}` : ""}`);
+  if (snip?.symbol) {
+    L.push(`  \`${snip.symbol}\``);
+  }
+  const sliceStr = renderSlice(top.path, data);
+  if (sliceStr) L.push(sliceStr);
+  const chain = [];
+  const fwd = data.forwardImports.get(top.path);
+  const rev = data.reverseImports.get(top.path);
+  if (rev?.length || fwd?.length) {
+    const callers = rev?.slice(0, 2) ?? [];
+    const deps = fwd?.slice(0, 2) ?? [];
+    if (callers.length || deps.length) {
+      const parts = [...callers.map((c) => `${c} \u2192`), top.path, ...deps.map((d) => `\u2192 ${d}`)];
+      chain.push(parts.join(" "));
+    }
+  }
+  if (chain.length) {
+    L.push("");
+    L.push("## Call Chain");
+    for (const c of chain) L.push(c);
   }
-  const denom = Math.sqrt(na) * Math.sqrt(nb);
-  return denom > 0 ? dot / denom : 0;
+  if (files.length > 1) {
+    L.push("");
+    L.push("## Related");
+    for (let i = 1; i < Math.min(files.length, 5); i++) {
+      const f = files[i];
+      const p = getPurpose(f.path, data);
+      const cochangeStr = renderCochanges(f.path, data.cochanges, 1);
+      L.push(`- ${f.path}${p ? ` \u2014 ${p}` : ""}${cochangeStr ? ` (${cochangeStr})` : ""}`);
+      const relSlice = renderSlice(f.path, data);
+      if (relSlice) L.push(relSlice);
+    }
+  }
+  return L.join("\n");
 }
-function agglomerativeCluster(terms, embeddings) {
-  const n = terms.length;
-  const pairs = [];
-  for (let i = 0; i < n; i++) {
-    for (let j = i + 1; j < n; j++) {
-      const sim = cosine(embeddings[i], embeddings[j]);
-      if (sim >= SIMILARITY_THRESHOLD) pairs.push({ i, j, sim });
+function stripCodeSlices(lines) {
+  const result = [];
+  let inFence = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```") && !inFence) {
+      inFence = true;
+      continue;
+    }
+    if (inFence && line.trimStart().startsWith("```")) {
+      inFence = false;
+      continue;
     }
+    if (!inFence) result.push(line);
   }
-  pairs.sort((a, b) => b.sim - a.sim);
-  const parent = new Int32Array(n);
-  const size = new Uint16Array(n);
-  for (let i = 0; i < n; i++) {
-    parent[i] = i;
-    size[i] = 1;
+  return result;
+}
+function progressiveStrip(output, _data) {
+  let lines = output.split("\n");
+  if (estimateTokens(lines.join("\n")) > TOKEN_CAP) {
+    lines = stripCodeSlices(lines);
   }
-  function find(x) {
-    while (parent[x] !== x) {
-      parent[x] = parent[parent[x]];
-      x = parent[x];
-    }
-    return x;
+  if (estimateTokens(lines.join("\n")) > TOKEN_CAP) {
+    lines = lines.map((l) => {
+      if (l.trimStart().startsWith("Co-changes:")) {
+        const match2 = l.match(/Co-changes:\s*([^,]+)/);
+        if (match2) return `${l.substring(0, l.indexOf("Co-changes:"))}Co-changes: ${match2[1].trim()}`;
+      }
+      return l;
+    });
   }
-  for (const { i, j } of pairs) {
-    const ri = find(i), rj = find(j);
-    if (ri === rj) continue;
-    if (size[ri] + size[rj] > MAX_CLUSTER_SIZE) continue;
-    if (size[ri] >= size[rj]) {
-      parent[rj] = ri;
-      size[ri] += size[rj];
-    } else {
-      parent[ri] = rj;
-      size[rj] += size[ri];
+  if (estimateTokens(lines.join("\n")) > TOKEN_CAP) {
+    const testIdx = lines.findIndex((l) => l.startsWith("## Tests"));
+    if (testIdx >= 0) {
+      let endIdx = lines.findIndex((l, i) => i > testIdx && l.startsWith("## "));
+      if (endIdx < 0) endIdx = lines.length;
+      lines.splice(testIdx, endIdx - testIdx);
     }
   }
-  const clusterMap = /* @__PURE__ */ new Map();
-  for (let i = 0; i < n; i++) {
-    const root = find(i);
-    const arr = clusterMap.get(root) ?? [];
-    arr.push(i);
-    clusterMap.set(root, arr);
+  if (estimateTokens(lines.join("\n")) > TOKEN_CAP) {
+    lines = lines.filter((l) => {
+      const trimmed = l.trimStart();
+      return !(trimmed.startsWith("\u2190") || trimmed.startsWith("\u2192")) || !trimmed.includes("|");
+    });
   }
-  return [...clusterMap.values()].filter((c) => c.length >= 2);
-}
-async function buildVocabClusters(db, repoId, caps, force = false) {
-  if (!caps?.embedTexts) {
-    console.error("[LENS] Vocab clusters: skipped (no embedTexts capability)");
-    return;
+  if (estimateTokens(lines.join("\n")) > TOKEN_CAP) {
+    const reduced = [];
+    let fileCount = 0;
+    for (const line of lines) {
+      if (/^\d+\./.test(line.trimStart())) {
+        fileCount++;
+        if (fileCount > 5) continue;
+      }
+      reduced.push(line);
+    }
+    lines = reduced;
   }
-  const repo = repoQueries.getById(db, repoId);
-  if (!repo) return;
-  if (!force && repo.last_vocab_cluster_commit && repo.last_vocab_cluster_commit === repo.last_indexed_commit) {
-    console.error("[LENS] Vocab clusters: skipped (unchanged since last build)");
-    return;
+  if (estimateTokens(lines.join("\n")) > TOKEN_CAP) {
+    lines = lines.map((l) => {
+      const dashIdx = l.indexOf(" \u2014 ");
+      if (dashIdx > 0 && (l.includes("**") || /^\d+\./.test(l.trimStart()))) {
+        return l.substring(0, dashIdx);
+      }
+      return l;
+    });
   }
-  const rows = metadataQueries.getByRepo(db, repoId).map((r) => ({
-    path: r.path,
-    exports: Array.isArray(r.exports) ? r.exports : jsonParse(r.exports, [])
-  }));
-  if (rows.length === 0) {
-    console.error("[LENS] Vocab clusters: skipped (no metadata rows)");
-    return;
+  return lines.join("\n");
+}
+function filterByScoreRelevance(data) {
+  if (!data.scores || data.scores.size === 0) return data;
+  const topScore = Math.max(...data.scores.values());
+  if (topScore <= 0) return data;
+  const threshold = topScore * 0.15;
+  const filtered = data.files.filter((f) => {
+    const score = data.scores?.get(f.path);
+    if (score === void 0) return data.files.indexOf(f) < 5;
+    return score >= threshold;
+  });
+  return { ...data, files: filtered };
+}
+function formatContextPack(data) {
+  const filtered = filterByScoreRelevance(data);
+  let output;
+  switch (filtered.queryKind) {
+    case "symbol":
+      output = formatSymbol(filtered);
+      break;
+    case "error_message":
+      output = formatError(filtered);
+      break;
+    case "stack_trace":
+      output = formatStackTrace(filtered);
+      break;
+    default:
+      output = formatNatural(filtered);
+      break;
   }
-  const { terms, termToFiles } = extractVocab(rows);
-  if (terms.length < 4) {
-    console.error(`[LENS] Vocab clusters: skipped (only ${terms.length} terms, need \u22654)`);
-    return;
+  if (estimateTokens(output) > TOKEN_CAP) {
+    output = progressiveStrip(output, filtered);
   }
-  console.error(`[LENS] Vocab clusters: embedding ${terms.length} terms in ${Math.ceil(terms.length / TERM_BATCH_SIZE)} batches...`);
-  let embeddings;
-  try {
-    const results = [];
-    for (let i = 0; i < terms.length; i += TERM_BATCH_SIZE) {
-      const batch = terms.slice(i, i + TERM_BATCH_SIZE);
-      const vecs = await caps.embedTexts(batch, false);
-      results.push(...vecs);
+  return output;
+}
+function extractFrames(query) {
+  const frames = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of FRAME_PATTERNS) {
+    pattern.lastIndex = 0;
+    let m;
+    while (m = pattern.exec(query)) {
+      const raw2 = m[1].replace(/^\.\//, "").replace(/^\/+/, "");
+      const line = Number.parseInt(m[2], 10);
+      const key = `${raw2}:${line}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        frames.push({ path: raw2, line });
+      }
     }
-    embeddings = results;
-  } catch (err) {
-    console.error(`[LENS] Vocab clusters: embed failed (${terms.length} terms):`, err.message);
-    return;
   }
-  const rawClusters = agglomerativeCluster(terms, embeddings);
-  console.error(`[LENS] Vocab clusters: ${rawClusters.length} clusters from ${terms.length} terms`);
-  const clusters = rawClusters.map((indices) => {
-    const clusterTerms = indices.map((i) => terms[i]);
-    const fileSet = /* @__PURE__ */ new Set();
-    for (const t of clusterTerms) {
-      const files = termToFiles.get(t);
-      if (files) for (const f of files) fileSet.add(f);
-    }
-    return { terms: clusterTerms, files: [...fileSet].sort() };
-  }).filter((c) => c.files.length > 0).sort((a, b) => b.files.length - a.files.length).slice(0, MAX_CLUSTERS);
-  repoQueries.updateVocabClusters(db, repoId, clusters, repo.last_indexed_commit ?? void 0);
+  return frames;
 }
-async function handleFileChange(db, repoId, repoRoot, absPath) {
-  const relPath = relative3(repoRoot, absPath);
-  if (isBinaryExt(relPath)) return;
-  try {
-    const s = await stat22(absPath);
-    if (s.size > MAX_FILE_SIZE) return;
-  } catch {
-    return;
+function tokenize(query) {
+  return query.toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS.has(w));
+}
+function parseQuery(query) {
+  const naturalTokens = tokenize(query);
+  const frames = extractFrames(query);
+  if (frames.length >= 2) {
+    return { kind: "stack_trace", raw: query, frames, symbol: null, errorToken: null, naturalTokens };
   }
-  let content;
-  try {
-    content = await readFile2(absPath, "utf-8");
-  } catch {
-    return;
+  const trimmed = query.trim();
+  if (SYMBOL_RE.test(trimmed) && trimmed.length >= 4 && CASING_BOUNDARY.test(trimmed)) {
+    return { kind: "symbol", raw: query, frames: [], symbol: trimmed, errorToken: null, naturalTokens };
   }
-  const language = detectLanguage(relPath);
-  const newChunks = chunkFile(content, DEFAULT_CHUNKING_PARAMS);
-  const existing = /* @__PURE__ */ new Map();
-  for (const row of chunkQueries.getByRepoPath(db, repoId, relPath)) {
-    existing.set(`${row.chunk_index}:${row.chunk_hash}`, row.id);
+  const errorCode = query.match(ERROR_CODE_RE)?.[0];
+  const errorSuffix = query.match(ERROR_SUFFIX_RE)?.[0];
+  const errorPrefix = query.match(ERROR_PREFIX_RE)?.[1];
+  const errorToken = errorCode || errorSuffix || errorPrefix || null;
+  if (errorToken) {
+    return { kind: "error_message", raw: query, frames, symbol: null, errorToken, naturalTokens };
   }
-  const newKeys = /* @__PURE__ */ new Set();
-  for (const chunk of newChunks) {
-    const key = `${chunk.chunk_index}:${chunk.chunk_hash}`;
-    newKeys.add(key);
-    if (existing.has(key)) {
-      chunkQueries.updateLastSeen(db, existing.get(key), repoId, "watcher");
-    } else {
-      chunkQueries.upsert(
-        db,
-        repoId,
-        relPath,
-        chunk.chunk_index,
-        chunk.start_line,
-        chunk.end_line,
-        chunk.content,
-        chunk.chunk_hash,
-        "watcher",
-        language
-      );
-    }
-  }
-  for (const [key, id] of existing) {
-    if (!newKeys.has(key)) chunkQueries.deleteById(db, id, repoId);
-  }
-  const entry = watchers.get(repoId);
-  if (entry) entry.changedFiles++;
-}
-async function handleFileDelete(db, repoId, repoRoot, absPath) {
-  const relPath = relative3(repoRoot, absPath);
-  if (isBinaryExt(relPath)) return;
-  chunkQueries.deleteByRepoPath(db, repoId, relPath);
-  const entry = watchers.get(repoId);
-  if (entry) entry.deletedFiles++;
-}
-function debouncedHandler(key, fn) {
-  const existing = debounceTimers.get(key);
-  if (existing) clearTimeout(existing);
-  debounceTimers.set(
-    key,
-    setTimeout(() => {
-      debounceTimers.delete(key);
-      fn().catch(() => {
-      });
-    }, DEBOUNCE_MS)
-  );
-}
-function startWatcher(db, repoId, rootPath) {
-  if (watchers.has(repoId)) return { started: false, already_watching: true };
-  try {
-    const fsWatcher = watch(rootPath, {
-      ignored: IGNORED,
-      ignoreInitial: true,
-      awaitWriteFinish: { stabilityThreshold: 200 },
-      persistent: false,
-      usePolling: false,
-      depth: 5
-    });
-    const entry = {
-      watcher: fsWatcher,
-      repoRoot: rootPath,
-      repoId,
-      changedFiles: 0,
-      deletedFiles: 0,
-      startedAt: /* @__PURE__ */ new Date()
-    };
-    watchers.set(repoId, entry);
-    fsWatcher.on(
-      "add",
-      (path) => debouncedHandler(`${repoId}:${path}`, () => handleFileChange(db, repoId, rootPath, path))
-    );
-    fsWatcher.on(
-      "change",
-      (path) => debouncedHandler(`${repoId}:${path}`, () => handleFileChange(db, repoId, rootPath, path))
-    );
-    fsWatcher.on(
-      "unlink",
-      (path) => debouncedHandler(`${repoId}:${path}`, () => handleFileDelete(db, repoId, rootPath, path))
-    );
-    fsWatcher.on("error", () => {
-      stopWatcher(repoId).catch(() => {
-      });
-    });
-    return { started: true, already_watching: false };
-  } catch {
-    return { started: false, already_watching: false };
-  }
-}
-async function stopWatcher(repoId) {
-  const entry = watchers.get(repoId);
-  if (!entry) return { stopped: false };
-  await entry.watcher.close();
-  watchers.delete(repoId);
-  for (const [key, timer] of debounceTimers) {
-    if (key.startsWith(`${repoId}:`)) {
-      clearTimeout(timer);
-      debounceTimers.delete(key);
-    }
-  }
-  return { stopped: true };
-}
-function getWatcherStatus(repoId) {
-  const entry = watchers.get(repoId);
-  if (!entry) return { watching: false, repo_root: null, changed_files: 0, deleted_files: 0, started_at: null };
-  return {
-    watching: true,
-    repo_root: entry.repoRoot,
-    changed_files: entry.changedFiles,
-    deleted_files: entry.deletedFiles,
-    started_at: entry.startedAt.toISOString()
-  };
-}
-function basename3(p) {
-  const i = p.lastIndexOf("/");
-  return i >= 0 ? p.substring(i + 1) : p;
-}
-function daysAgo(d) {
-  if (!d) return "unknown";
-  const days = Math.round((Date.now() - d.getTime()) / 864e5);
-  if (days === 0) return "today";
-  if (days === 1) return "1d ago";
-  return `${days}d ago`;
-}
-function formatContextPack(data) {
-  const L = [];
-  const files = data.files.slice(0, 15);
-  const exportsMap = /* @__PURE__ */ new Map();
-  for (const m of data.metadata) {
-    if (m.exports?.length) exportsMap.set(m.path, m.exports);
-  }
-  L.push(`# ${data.goal}`);
-  L.push("");
-  if (files.length > 0) {
-    L.push("## Files");
-    for (let i = 0; i < files.length; i++) {
-      const f = files[i];
-      const exports = exportsMap.get(f.path);
-      const exportStr = exports?.length ? ` \u2014 exports: ${exports.slice(0, 5).join(", ")}` : "";
-      L.push(`${i + 1}. ${f.path}${exportStr}`);
-    }
-    L.push("");
-  }
-  const depLines = [];
-  for (const f of files.slice(0, 5)) {
-    const fwd = data.forwardImports.get(f.path);
-    const rev = data.reverseImports.get(f.path);
-    const hop2 = data.hop2Deps.get(f.path);
-    if (!fwd?.length && !rev?.length) continue;
-    depLines.push(f.path);
-    if (fwd?.length) {
-      depLines.push(`  imports: ${fwd.slice(0, 5).map(basename3).join(", ")}`);
-    }
-    if (rev?.length) {
-      let revStr = rev.slice(0, 4).map(basename3).join(", ");
-      if (hop2?.length) {
-        revStr += ` \u2192 ${hop2.slice(0, 3).map(basename3).join(", ")}`;
-      }
-      depLines.push(`  imported by: ${revStr}`);
-    }
-  }
-  if (depLines.length > 0) {
-    L.push("## Dependency Graph");
-    for (const line of depLines) L.push(line);
-    L.push("");
-  }
-  if (data.cochanges.length > 0) {
-    const clusters = buildClusters(data.cochanges);
-    if (clusters.length > 0) {
-      L.push("## Co-change Clusters");
-      for (const c of clusters) {
-        L.push(`[${c.members.map(basename3).join(", ")}] \u2014 ${c.count} co-commits`);
-      }
-      L.push("");
-    }
-  }
-  const activityLines = [];
-  for (const f of files.slice(0, 5)) {
-    const stat32 = data.fileStats.get(f.path);
-    if (!stat32 || stat32.commit_count === 0) continue;
-    activityLines.push(
-      `${basename3(f.path)}: ${stat32.commit_count} commits, ${stat32.recent_count}/90d, last: ${daysAgo(stat32.last_modified)}`
-    );
-  }
-  if (activityLines.length > 0) {
-    L.push("## Activity");
-    for (const line of activityLines) L.push(line);
-  }
-  return L.join("\n");
-}
-function buildClusters(cochanges) {
-  const clusters = [];
-  for (const cc of cochanges) {
-    let merged = false;
-    for (const c of clusters) {
-      if (c.members.includes(cc.path) || c.members.includes(cc.partner)) {
-        if (!c.members.includes(cc.path)) c.members.push(cc.path);
-        if (!c.members.includes(cc.partner)) c.members.push(cc.partner);
-        c.count = Math.max(c.count, cc.count);
-        merged = true;
-        break;
-      }
-    }
-    if (!merged) {
-      clusters.push({ members: [cc.path, cc.partner], count: cc.count });
-    }
-  }
-  return clusters.filter((c) => c.count >= 2).sort((a, b) => b.count - a.count).slice(0, 5);
+  return { kind: "natural", raw: query, frames, symbol: null, errorToken: null, naturalTokens };
 }
 function stem(word) {
   if (word.length <= 4) return word;
@@ -9155,6 +8867,7 @@ function stem(word) {
 }
 function expandKeywords(words, clusters) {
   const exact = /* @__PURE__ */ new Set();
+  const expanded = /* @__PURE__ */ new Set();
   const stemmed = /* @__PURE__ */ new Set();
   const clusterFiles = /* @__PURE__ */ new Set();
   for (const w of words) {
@@ -9174,21 +8887,26 @@ function expandKeywords(words, clusters) {
   for (const w of words) {
     const synonyms = CONCEPT_SYNONYMS[w];
     if (synonyms) {
-      for (const syn of synonyms) exact.add(syn);
+      for (const syn of synonyms) {
+        if (!exact.has(syn)) expanded.add(syn);
+      }
     }
   }
   if (clusters) {
     for (const w of words) {
       for (const cluster of clusters) {
         if (cluster.terms.includes(w) || cluster.terms.some((t) => stem(t) === stem(w))) {
-          for (const t of cluster.terms) exact.add(t);
+          for (const t of cluster.terms) {
+            if (!exact.has(t)) expanded.add(t);
+          }
           for (const f of cluster.files) clusterFiles.add(f);
         }
       }
     }
   }
   for (const e of exact) stemmed.delete(e);
-  return { exact: [...exact], stemmed: [...stemmed], clusterFiles };
+  for (const e of expanded) stemmed.delete(e);
+  return { exact: [...exact], expanded, stemmed: [...stemmed], clusterFiles };
 }
 function isNoisePath(path) {
   const lower = path.toLowerCase();
@@ -9212,10 +8930,10 @@ function buildTermWeights(words, metadata) {
   }
   return weights;
 }
-function interpretQuery(query, metadata, fileStats2, vocabClusters, indegrees, maxImportDepth) {
+function interpretQuery(query, metadata, fileStats2, vocabClusters, indegrees, maxImportDepth, parsed) {
   const rawWords = query.toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS2.has(w));
-  const { exact, stemmed, clusterFiles } = expandKeywords(rawWords, vocabClusters ?? null);
-  const allTerms = [...exact, ...stemmed];
+  const { exact, expanded, stemmed, clusterFiles } = expandKeywords(rawWords, vocabClusters ?? null);
+  const allTerms = [...exact, ...expanded, ...stemmed];
   const termWeights = buildTermWeights(allTerms, metadata);
   const exportTokensMap = /* @__PURE__ */ new Map();
   for (const f of metadata) {
@@ -9242,6 +8960,32 @@ function interpretQuery(query, metadata, fileStats2, vocabClusters, indegrees, m
     const dirTokens = pathSegments.slice(-4, -1).flatMap((s) => s.replace(/\./g, " ").split(/\s+/)).filter((t) => t.length >= 2);
     const pathTokenSet = /* @__PURE__ */ new Set([...fileTokens, ...dirTokens]);
     const expTokens = exportTokensMap.get(f.path);
+    if (parsed) {
+      if (parsed.kind === "stack_trace") {
+        for (const frame of parsed.frames) {
+          if (f.path.endsWith(frame.path) || frame.path.endsWith(f.path)) {
+            score += 50;
+          }
+        }
+      } else if (parsed.kind === "symbol" && parsed.symbol) {
+        const sym = parsed.symbol;
+        if ((f.exports ?? []).includes(sym)) score += 100;
+        else if ((f.internals ?? []).includes(sym)) score += 80;
+      } else if (parsed.kind === "error_message") {
+        if (parsed.errorToken) {
+          const token = parsed.errorToken.toLowerCase();
+          if (exportsLower.includes(token) || internalsLower.includes(token) || pathLower.includes(token)) {
+            score += 30;
+          }
+        }
+        const rawError = parsed.raw.replace(/^(Error|TypeError|ReferenceError|SyntaxError|RangeError|FATAL|WARN|ERR):\s*/i, "").toLowerCase().trim();
+        if (rawError.length >= 5) {
+          if (docLower.includes(rawError) || sectionsLower.includes(rawError) || internalsLower.includes(rawError) || purposeLower.includes(rawError)) {
+            score += 40;
+          }
+        }
+      }
+    }
     for (const w of exact) {
       const weight = termWeights.get(w) ?? 1;
       let termScore = 0;
@@ -9255,6 +8999,16 @@ function interpretQuery(query, metadata, fileStats2, vocabClusters, indegrees, m
       if (termScore > 0) matchedTerms++;
       score += termScore;
     }
+    for (const w of expanded) {
+      const weight = (termWeights.get(w) ?? 1) * 0.5;
+      let termScore = 0;
+      if (expTokens?.has(w)) termScore += 2 * weight;
+      else if (exportsLower.includes(w)) termScore += 1.5 * weight;
+      if (docLower.includes(w) || purposeLower.includes(w)) termScore += 1 * weight;
+      if (internalsLower.includes(w)) termScore += 1 * weight;
+      if (termScore > 0) matchedTerms++;
+      score += termScore;
+    }
     for (const w of stemmed) {
       const weight = termWeights.get(w) ?? 1;
       let termScore = 0;
@@ -9270,7 +9024,7 @@ function interpretQuery(query, metadata, fileStats2, vocabClusters, indegrees, m
       score *= 1 + coverage * coverage;
     }
     if (score > 0 && isNoisePath(f.path)) {
-      score *= 0.3;
+      score = 0;
     }
     const exportCount = (f.exports ?? []).length;
     if (exportCount > 5 && score > 0) {
@@ -9304,14 +9058,27 @@ function interpretQuery(query, metadata, fileStats2, vocabClusters, indegrees, m
     deduped.push(f);
     if (deduped.length >= fileCap) break;
   }
+  const scores = /* @__PURE__ */ new Map();
+  for (const f of deduped) scores.set(f.path, f.score);
   return {
     fileCap,
+    scores,
     files: deduped.map((f) => {
-      const reason = f.docstring?.slice(0, 80) || (f.exports?.length ? `exports: ${f.exports.slice(0, 4).join(", ")}` : "path match");
+      const reason = truncateAtWord(f.docstring, 80) || formatExports(f.exports) || f.path.split("/").pop() || "";
       return { path: f.path, reason };
     })
   };
 }
+function truncateAtWord(s, max) {
+  if (!s) return "";
+  if (s.length <= max) return s;
+  const cut = s.lastIndexOf(" ", max);
+  return cut > max * 0.5 ? `${s.slice(0, cut)}...` : `${s.slice(0, max)}...`;
+}
+function formatExports(exports) {
+  if (!exports?.length) return "";
+  return `exports: ${exports.slice(0, 4).join(", ")}`;
+}
 function siblingKey(path) {
   const lastSlash = path.lastIndexOf("/");
   const dir = lastSlash >= 0 ? path.substring(0, lastSlash) : "";
@@ -9320,6 +9087,99 @@ function siblingKey(path) {
   const tokens = stem2.split(/[-.]/).slice(0, 3).join("-");
   return `${dir}/${tokens}`;
 }
+function findSymbolLine(symbol, chunkRows) {
+  const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`\\b${escaped}\\b`);
+  for (const chunk of chunkRows) {
+    const lines = chunk.content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i]) && SYMBOL_DEF_RE.test(lines[i])) {
+        return chunk.start_line + i;
+      }
+    }
+  }
+  for (const chunk of chunkRows) {
+    const lines = chunk.content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i])) {
+        return chunk.start_line + i;
+      }
+    }
+  }
+  return null;
+}
+function pickBestExport(exports, queryTokens) {
+  if (exports.length <= 1 || !queryTokens.length) return exports[0];
+  let best = exports[0];
+  let bestScore = 0;
+  for (const exp of exports) {
+    const lower = exp.toLowerCase();
+    const expTokens = lower.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[\s_-]+/);
+    let score = 0;
+    for (const qt of queryTokens) {
+      if (lower.includes(qt)) score += 2;
+      else if (expTokens.some((t) => t.includes(qt) || qt.includes(t))) score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      best = exp;
+    }
+  }
+  return best;
+}
+function resolveSnippets(db, repoId, files, metadata, parsed, limit = 5) {
+  const result = /* @__PURE__ */ new Map();
+  const topFiles = files.slice(0, limit);
+  const topPaths = topFiles.map((f) => f.path);
+  const allChunks = chunkQueries.getByRepoPaths(db, repoId, topPaths);
+  const chunksByPath = /* @__PURE__ */ new Map();
+  for (const c of allChunks) {
+    const arr = chunksByPath.get(c.path) ?? [];
+    arr.push({ start_line: c.start_line, content: c.content });
+    chunksByPath.set(c.path, arr);
+  }
+  const metaMap = /* @__PURE__ */ new Map();
+  for (const m of metadata) metaMap.set(m.path, m);
+  const frameByPath = /* @__PURE__ */ new Map();
+  for (const frame of parsed.frames) {
+    for (const p of topPaths) {
+      if (p.endsWith(frame.path) || frame.path.endsWith(p)) {
+        frameByPath.set(p, frame.line);
+      }
+    }
+  }
+  for (const f of topFiles) {
+    const chunks2 = chunksByPath.get(f.path) ?? [];
+    const meta = metaMap.get(f.path);
+    const frameLine = frameByPath.get(f.path);
+    if (frameLine !== void 0) {
+      result.set(f.path, { path: f.path, symbol: null, line: frameLine, matchKind: "frame" });
+      continue;
+    }
+    if (parsed.symbol) {
+      const exports = meta?.exports ?? [];
+      const internals = meta?.internals ?? [];
+      if (exports.includes(parsed.symbol)) {
+        const line = findSymbolLine(parsed.symbol, chunks2);
+        result.set(f.path, { path: f.path, symbol: parsed.symbol, line, matchKind: "export" });
+        continue;
+      }
+      if (internals.includes(parsed.symbol)) {
+        const line = findSymbolLine(parsed.symbol, chunks2);
+        result.set(f.path, { path: f.path, symbol: parsed.symbol, line, matchKind: "internal" });
+        continue;
+      }
+    }
+    if (meta?.exports?.length) {
+      const bestExport = pickBestExport(meta.exports, parsed.naturalTokens);
+      const line = findSymbolLine(bestExport, chunks2);
+      result.set(f.path, { path: f.path, symbol: bestExport, line, matchKind: "export" });
+      continue;
+    }
+    result.set(f.path, { path: f.path, symbol: null, line: null, matchKind: null });
+  }
+  return result;
+}
 function loadFileMetadata(db, repoId) {
   return metadataQueries.getByRepo(db, repoId);
 }
@@ -9382,12 +9242,43 @@ function getIndegrees(db, repoId) {
 function getCochangePartners(db, repoId, paths, minCount = 5, limit = 10) {
   return cochangeQueries.getPartners(db, repoId, paths, minCount, limit);
 }
+function discoverTestFiles(reverseImports, cochanges, metadataPaths, sourcePaths) {
+  const result = /* @__PURE__ */ new Map();
+  for (const src of sourcePaths) {
+    const tests = /* @__PURE__ */ new Set();
+    const importers = reverseImports.get(src) ?? [];
+    for (const imp of importers) {
+      if (TEST_PATTERN.test(imp)) tests.add(imp);
+    }
+    for (const cc of cochanges) {
+      const partner = cc.path === src ? cc.partner : cc.partner === src ? cc.path : null;
+      if (partner && TEST_PATTERN.test(partner)) tests.add(partner);
+    }
+    const ext = src.slice(src.lastIndexOf("."));
+    const base = src.slice(0, src.lastIndexOf("."));
+    const dir = src.slice(0, src.lastIndexOf("/"));
+    const name = src.slice(src.lastIndexOf("/") + 1, src.lastIndexOf("."));
+    const candidates = [
+      `${base}.test${ext}`,
+      `${base}.spec${ext}`,
+      `${dir}/__tests__/${name}${ext}`,
+      `${dir}/__tests__/${name}.test${ext}`
+    ];
+    for (const c of candidates) {
+      if (metadataPaths.has(c)) tests.add(c);
+    }
+    if (tests.size > 0) {
+      result.set(src, [...tests].slice(0, 3));
+    }
+  }
+  return result;
+}
 function loadVocabClusters(db, repoId) {
   const repo = repoQueries.getById(db, repoId);
   if (!repo?.vocab_clusters) return null;
   return jsonParse(repo.vocab_clusters, null);
 }
-function cosine2(a, b) {
+function cosine(a, b) {
   let dot = 0, na = 0, nb = 0;
   for (let i = 0; i < a.length; i++) {
     dot += a[i] * b[i];
@@ -9410,7 +9301,7 @@ async function vectorSearch(db, repoId, query, limit, caps, codeOnly = true) {
     end_line: c.end_line,
     content: c.content,
     language: c.language,
-    score: cosine2(queryArr, c.embedding)
+    score: cosine(queryArr, c.embedding)
   })).filter((c) => !codeOnly || !isDocFile(c.path)).sort((a, b) => b.score - a.score).slice(0, limit);
   return scored;
 }
@@ -9442,14 +9333,21 @@ async function buildContext(db, repoId, goal, caps, trace, options) {
     const repo = repoQueries.getById(db, repoId);
     const commit = repo?.last_indexed_commit ?? null;
     const useEmb = options?.useEmbeddings !== false;
-    const key = cacheKey(repoId, goal, commit, useEmb);
-    const cached2 = cacheGet(key);
-    if (cached2) {
-      trace?.add("cache", 0, "HIT");
-      track(db, "context", { duration_ms: Date.now() - start, result_count: cached2.stats.files_in_context, cache_hit: true });
-      return { ...cached2, stats: { ...cached2.stats, cached: true, duration_ms: Date.now() - start } };
+    if (!options?.skipCache) {
+      const key = cacheKey(repoId, goal, commit, useEmb);
+      const cached2 = cacheGet(key);
+      if (cached2) {
+        trace?.add("cache", 0, "HIT");
+        track(db, "context", {
+          duration_ms: Date.now() - start,
+          result_count: cached2.stats.files_in_context,
+          cache_hit: true
+        });
+        return { ...cached2, stats: { ...cached2.stats, cached: true, duration_ms: Date.now() - start } };
+      }
     }
     const embAvailable = useEmb && (await Promise.resolve().then(() => (init_queries(), queries_exports))).chunkQueries.hasEmbeddings(db, repoId);
+    const parsed = parseQuery(goal);
     trace?.step("loadStructural");
     const metadata = loadFileMetadata(db, repoId);
     const allStats = getAllFileStats(db, repoId);
@@ -9465,11 +9363,44 @@ async function buildContext(db, repoId, goal, caps, trace, options) {
       statsForInterpreter.set(path, { commit_count: stat32.commit_count, recent_count: stat32.recent_count });
     }
     trace?.step("interpretQuery");
-    const interpreted = interpretQuery(goal, metadata, statsForInterpreter, vocabClusters, indegreeMap, maxImportDepth);
-    trace?.end("interpretQuery", `${interpreted.files.length} files`);
+    const interpreted = interpretQuery(
+      goal,
+      metadata,
+      statsForInterpreter,
+      vocabClusters,
+      indegreeMap,
+      maxImportDepth,
+      parsed
+    );
+    trace?.end("interpretQuery", `${interpreted.files.length} files (${parsed.kind})`);
+    if (parsed.kind === "error_message") {
+      trace?.step("errorContentSearch");
+      const rawError = parsed.raw.replace(/^(Error|TypeError|ReferenceError|SyntaxError|RangeError|FATAL|WARN|ERR):\s*/i, "").trim();
+      if (rawError.length >= 5) {
+        const contentHits = chunkQueries.searchContent(db, repoId, rawError).filter((p) => !isNoisePath(p));
+        const scored = contentHits.filter((p) => (interpreted.scores.get(p) ?? 0) > 0);
+        const unscored = contentHits.filter((p) => (interpreted.scores.get(p) ?? 0) === 0);
+        const capped = [...scored.slice(0, 3), ...unscored.slice(0, Math.max(0, 3 - scored.length))];
+        const existingSet = new Set(interpreted.files.map((f) => f.path));
+        for (const p of capped) {
+          const currentScore = interpreted.scores.get(p) ?? 0;
+          interpreted.scores.set(p, currentScore + 40);
+          if (!existingSet.has(p)) {
+            const meta = metadata.find((m) => m.path === p);
+            interpreted.files.push({
+              path: p,
+              reason: meta?.docstring?.slice(0, 80) || `contains "${rawError.slice(0, 30)}"`
+            });
+            existingSet.add(p);
+          }
+        }
+        interpreted.files.sort((a, b) => (interpreted.scores.get(b.path) ?? 0) - (interpreted.scores.get(a.path) ?? 0));
+      }
+      trace?.end("errorContentSearch");
+    }
     trace?.step("cochangePromotion");
     const topForCochange = interpreted.files.slice(0, 5).map((f) => f.path);
-    const cochangePartners = getCochangePartners(db, repoId, topForCochange, 3, 20);
+    const cochangePartners = getCochangePartners(db, repoId, topForCochange, 5, 15);
     const existingPathSet = new Set(interpreted.files.map((f) => f.path));
     let promoted = 0;
     for (const cp of cochangePartners) {
@@ -9549,6 +9480,20 @@ async function buildContext(db, repoId, goal, caps, trace, options) {
       }
     }
     trace?.end("structuralEnrichment");
+    trace?.step("resolveSnippets");
+    const snippets = resolveSnippets(db, repoId, interpreted.files, metadata, parsed, 5);
+    const metadataPaths = new Set(metadata.map((m) => m.path));
+    const testFiles = discoverTestFiles(
+      reverseImports,
+      cochanges,
+      metadataPaths,
+      interpreted.files.slice(0, 5).map((f) => f.path)
+    );
+    trace?.end("resolveSnippets", `${snippets.size} snippets, ${testFiles.size} test maps`);
+    trace?.step("sliceContext");
+    const { sliceContext: sliceCtx } = await Promise.resolve().then(() => (init_slicer(), slicer_exports));
+    const slices = sliceCtx(db, repoId, snippets, parsed.kind);
+    trace?.end("sliceContext", `${slices.size} slices`);
     trace?.step("formatContextPack");
     const data = {
       goal,
@@ -9558,7 +9503,12 @@ async function buildContext(db, repoId, goal, caps, trace, options) {
       forwardImports,
       hop2Deps,
       cochanges,
-      fileStats: allStats
+      fileStats: allStats,
+      scores: interpreted.scores,
+      snippets,
+      slices,
+      testFiles,
+      queryKind: parsed.kind
     };
     const contextPack = formatContextPack(data);
     trace?.end("formatContextPack");
@@ -9571,19 +9521,742 @@ async function buildContext(db, repoId, goal, caps, trace, options) {
         cached: false
       }
     };
-    cacheSet(key, response);
-    track(db, "context", { duration_ms: response.stats.duration_ms, result_count: response.stats.files_in_context, cache_hit: false });
-    return response;
+    if (options?.includeRankedFiles) {
+      response.ranked_files = interpreted.files.map((f) => ({
+        path: f.path,
+        reason: f.reason,
+        score: interpreted.scores.get(f.path) ?? 0
+      }));
+      response.query_kind = parsed.kind;
+    }
+    if (!options?.skipCache) {
+      const key = cacheKey(repoId, goal, commit, useEmb);
+      cacheSet(key, response);
+    }
+    track(db, "context", {
+      duration_ms: response.stats.duration_ms,
+      result_count: response.stats.files_in_context,
+      cache_hit: false
+    });
+    return response;
+  } catch {
+    return {
+      context_pack: `# ${goal}
+
+Context generation failed.`,
+      stats: { files_in_context: 0, index_fresh: false, duration_ms: Date.now() - start, cached: false }
+    };
+  }
+}
+function resolveDbPath(customPath) {
+  if (customPath) return customPath;
+  const dir = join3(homedir(), ".lens");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join3(dir, "data.db");
+}
+function openDb(customPath) {
+  if (_db) return _db;
+  const dbPath = resolveDbPath(customPath);
+  const sqlite = new Database(dbPath);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("busy_timeout = 5000");
+  sqlite.pragma("foreign_keys = ON");
+  const db = drizzle(sqlite, { schema: schema_exports });
+  sqlite.exec(createTablesSql());
+  const cols = new Set(sqlite.pragma("table_info(file_metadata)").map((c) => c.name));
+  if (!cols.has("sections")) sqlite.exec("ALTER TABLE file_metadata ADD COLUMN sections TEXT DEFAULT '[]'");
+  if (!cols.has("internals")) sqlite.exec("ALTER TABLE file_metadata ADD COLUMN internals TEXT DEFAULT '[]'");
+  const repoCols = new Set(sqlite.pragma("table_info(repos)").map((c) => c.name));
+  if (!repoCols.has("enable_embeddings"))
+    sqlite.exec("ALTER TABLE repos ADD COLUMN enable_embeddings INTEGER NOT NULL DEFAULT 1");
+  if (!repoCols.has("enable_summaries"))
+    sqlite.exec("ALTER TABLE repos ADD COLUMN enable_summaries INTEGER NOT NULL DEFAULT 1");
+  if (!repoCols.has("enable_vocab_clusters"))
+    sqlite.exec("ALTER TABLE repos ADD COLUMN enable_vocab_clusters INTEGER NOT NULL DEFAULT 1");
+  if (!repoCols.has("last_vocab_cluster_commit"))
+    sqlite.exec("ALTER TABLE repos ADD COLUMN last_vocab_cluster_commit TEXT");
+  const logCols = new Set(sqlite.pragma("table_info(request_logs)").map((c) => c.name));
+  if (!logCols.has("response_body")) sqlite.exec("ALTER TABLE request_logs ADD COLUMN response_body TEXT");
+  if (!logCols.has("trace")) sqlite.exec("ALTER TABLE request_logs ADD COLUMN trace TEXT");
+  _db = db;
+  _raw = sqlite;
+  return db;
+}
+function getDb() {
+  if (!_db) throw new Error("Database not initialized. Call openDb() first.");
+  return _db;
+}
+function getRawDb() {
+  if (!_raw) throw new Error("Database not initialized. Call openDb() first.");
+  return _raw;
+}
+function closeDb() {
+  if (_raw) _raw.close();
+  _db = null;
+  _raw = null;
+}
+function createTablesSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS repos (
+      id TEXT PRIMARY KEY,
+      identity_key TEXT UNIQUE NOT NULL,
+      name TEXT NOT NULL,
+      root_path TEXT NOT NULL,
+      remote_url TEXT,
+      last_indexed_commit TEXT,
+      index_status TEXT NOT NULL DEFAULT 'pending',
+      last_indexed_at TEXT,
+      last_git_analysis_commit TEXT,
+      max_import_depth INTEGER DEFAULT 0,
+      vocab_clusters TEXT,
+      last_vocab_cluster_commit TEXT,
+      enable_embeddings INTEGER NOT NULL DEFAULT 1,
+      enable_summaries INTEGER NOT NULL DEFAULT 1,
+      enable_vocab_clusters INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_repos_identity ON repos(identity_key);
+
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+      path TEXT NOT NULL,
+      chunk_index INTEGER NOT NULL,
+      start_line INTEGER NOT NULL,
+      end_line INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      chunk_hash TEXT NOT NULL,
+      last_seen_commit TEXT NOT NULL,
+      language TEXT,
+      embedding BLOB,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(repo_id, path, chunk_index, chunk_hash)
+    );
+    CREATE INDEX IF NOT EXISTS idx_chunks_repo_path ON chunks(repo_id, path);
+    CREATE INDEX IF NOT EXISTS idx_chunks_repo ON chunks(repo_id);
+    CREATE INDEX IF NOT EXISTS idx_chunks_hash ON chunks(repo_id, chunk_hash);
+
+    CREATE TABLE IF NOT EXISTS file_metadata (
+      id TEXT PRIMARY KEY,
+      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+      path TEXT NOT NULL,
+      language TEXT,
+      exports TEXT DEFAULT '[]',
+      imports TEXT DEFAULT '[]',
+      docstring TEXT DEFAULT '',
+      sections TEXT DEFAULT '[]',
+      internals TEXT DEFAULT '[]',
+      purpose TEXT DEFAULT '',
+      purpose_hash TEXT DEFAULT '',
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(repo_id, path)
+    );
+    CREATE INDEX IF NOT EXISTS idx_file_metadata_repo ON file_metadata(repo_id);
+
+    CREATE TABLE IF NOT EXISTS file_imports (
+      id TEXT PRIMARY KEY,
+      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+      source_path TEXT NOT NULL,
+      target_path TEXT NOT NULL,
+      UNIQUE(repo_id, source_path, target_path)
+    );
+    CREATE INDEX IF NOT EXISTS idx_file_imports_target ON file_imports(repo_id, target_path);
+
+    CREATE TABLE IF NOT EXISTS file_stats (
+      id TEXT PRIMARY KEY,
+      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+      path TEXT NOT NULL,
+      commit_count INTEGER NOT NULL DEFAULT 0,
+      recent_count INTEGER NOT NULL DEFAULT 0,
+      last_modified TEXT,
+      UNIQUE(repo_id, path)
+    );
+
+    CREATE TABLE IF NOT EXISTS file_cochanges (
+      id TEXT PRIMARY KEY,
+      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+      path_a TEXT NOT NULL,
+      path_b TEXT NOT NULL,
+      cochange_count INTEGER NOT NULL DEFAULT 1,
+      UNIQUE(repo_id, path_a, path_b)
+    );
+    CREATE INDEX IF NOT EXISTS idx_cochanges_lookup ON file_cochanges(repo_id, path_a);
+
+    CREATE TABLE IF NOT EXISTS usage_counters (
+      id TEXT PRIMARY KEY,
+      date TEXT NOT NULL UNIQUE,
+      context_queries INTEGER NOT NULL DEFAULT 0,
+      embedding_requests INTEGER NOT NULL DEFAULT 0,
+      embedding_chunks INTEGER NOT NULL DEFAULT 0,
+      purpose_requests INTEGER NOT NULL DEFAULT 0,
+      repos_indexed INTEGER NOT NULL DEFAULT 0,
+      synced_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_usage_counters_date ON usage_counters(date);
+
+    CREATE TABLE IF NOT EXISTS request_logs (
+      id TEXT PRIMARY KEY,
+      method TEXT NOT NULL,
+      path TEXT NOT NULL,
+      status INTEGER NOT NULL,
+      duration_ms INTEGER NOT NULL,
+      source TEXT NOT NULL DEFAULT 'api',
+      request_body TEXT,
+      response_size INTEGER,
+      response_body TEXT,
+      trace TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_request_logs_created ON request_logs(created_at);
+    CREATE INDEX IF NOT EXISTS idx_request_logs_source ON request_logs(source);
+
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS telemetry_events (
+      id TEXT PRIMARY KEY,
+      event_type TEXT NOT NULL,
+      event_data TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      synced_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_telemetry_events_type ON telemetry_events(event_type);
+    CREATE INDEX IF NOT EXISTS idx_telemetry_events_synced ON telemetry_events(synced_at);
+  `;
+}
+function hitAtN(expected, returned, n) {
+  const top = returned.slice(0, n);
+  return expected.some((e) => top.includes(e));
+}
+function entryHitAtN(entry, returned, n) {
+  if (!entry) return false;
+  return returned.slice(0, n).includes(entry);
+}
+function recallAtK(expected, returned, k) {
+  if (expected.length === 0) return 1;
+  const top = new Set(returned.slice(0, k));
+  const hits = expected.filter((e) => top.has(e)).length;
+  return hits / expected.length;
+}
+function computeMetrics(results) {
+  const total = results.length;
+  if (total === 0) {
+    return {
+      total: 0,
+      hit_at_1: 0,
+      hit_at_3: 0,
+      entry_hit_at_1: 0,
+      entry_hit_at_3: 0,
+      avg_recall_at_5: 0,
+      avg_duration_ms: 0,
+      by_kind: [],
+      results
+    };
+  }
+  const hit1 = results.filter((r) => r.hit_at_1).length;
+  const hit3 = results.filter((r) => r.hit_at_3).length;
+  const entryHit1 = results.filter((r) => r.entry_hit_at_1).length;
+  const entryHit3 = results.filter((r) => r.entry_hit_at_3).length;
+  const sumRecall = results.reduce((s, r) => s + r.recall_at_5, 0);
+  const sumDuration = results.reduce((s, r) => s + r.duration_ms, 0);
+  const kinds = [...new Set(results.map((r) => r.kind))];
+  const by_kind = kinds.map((kind) => {
+    const group = results.filter((r) => r.kind === kind);
+    const n = group.length;
+    return {
+      kind,
+      count: n,
+      hit_at_1: group.filter((r) => r.hit_at_1).length / n,
+      hit_at_3: group.filter((r) => r.hit_at_3).length / n,
+      entry_hit_at_1: group.filter((r) => r.entry_hit_at_1).length / n,
+      entry_hit_at_3: group.filter((r) => r.entry_hit_at_3).length / n,
+      avg_recall_at_5: group.reduce((s, r) => s + r.recall_at_5, 0) / n,
+      avg_duration_ms: Math.round(group.reduce((s, r) => s + r.duration_ms, 0) / n)
+    };
+  });
+  return {
+    total,
+    hit_at_1: hit1 / total,
+    hit_at_3: hit3 / total,
+    entry_hit_at_1: entryHit1 / total,
+    entry_hit_at_3: entryHit3 / total,
+    avg_recall_at_5: sumRecall / total,
+    avg_duration_ms: Math.round(sumDuration / total),
+    by_kind,
+    results
+  };
+}
+async function runEval(db, repoId, options) {
+  let queries = GOLD_DATASET;
+  if (options?.filterKind) {
+    queries = queries.filter((q) => q.kind === options.filterKind);
+  }
+  const results = [];
+  for (const gold of queries) {
+    const start = Date.now();
+    const response = await buildContext(db, repoId, gold.query, void 0, void 0, {
+      useEmbeddings: false,
+      includeRankedFiles: true,
+      skipCache: true
+    });
+    const duration3 = Date.now() - start;
+    const returned = (response.ranked_files ?? []).map((f) => f.path);
+    results.push({
+      id: gold.id,
+      query: gold.query,
+      kind: gold.kind,
+      expected_files: gold.expected_files,
+      expected_entry: gold.expected_entry,
+      returned_files: returned,
+      hit_at_1: hitAtN(gold.expected_files, returned, 1),
+      hit_at_3: hitAtN(gold.expected_files, returned, 3),
+      entry_hit_at_1: entryHitAtN(gold.expected_entry, returned, 1),
+      entry_hit_at_3: entryHitAtN(gold.expected_entry, returned, 3),
+      recall_at_5: recallAtK(gold.expected_files, returned, 5),
+      duration_ms: duration3,
+      file_count: returned.length
+    });
+  }
+  return computeMetrics(results);
+}
+function estimateTokens2(text22) {
+  return Math.ceil(text22.length / CHARS_PER_TOKEN);
+}
+async function ensureEmbedded(db, repoId, caps) {
+  const start = Date.now();
+  if (!caps?.embedTexts) {
+    return { embedded_count: 0, skipped_count: 0, duration_ms: 0 };
+  }
+  let embedded = 0;
+  let apiCalls = 0;
+  while (apiCalls < MAX_API_CALLS) {
+    const remaining = chunkQueries.countUnembedded(db, repoId);
+    if (remaining === 0) break;
+    const rows = chunkQueries.getUnembedded(db, repoId, POOL_SIZE);
+    if (rows.length === 0) break;
+    const validRows = rows.filter((r) => r.content.trim().length > 0);
+    if (validRows.length === 0) {
+      apiCalls++;
+      continue;
+    }
+    let offset = 0;
+    let poolFailed = false;
+    while (offset < validRows.length && apiCalls < MAX_API_CALLS) {
+      const batch = [];
+      let batchTokens = 0;
+      while (offset < validRows.length) {
+        const est = estimateTokens2(validRows[offset].content);
+        if (batch.length > 0 && batchTokens + est > MAX_BATCH_TOKENS) break;
+        batch.push(validRows[offset]);
+        batchTokens += est;
+        offset++;
+      }
+      try {
+        const texts = batch.map((r) => r.content);
+        const vectors = await caps.embedTexts(texts);
+        for (let i = 0; i < batch.length; i++) {
+          chunkQueries.updateEmbedding(db, batch[i].id, repoId, vectors[i]);
+        }
+        embedded += batch.length;
+      } catch (err) {
+        console.error(
+          `[LENS] Embed batch failed (${batch.length} chunks, ~${batchTokens} tokens):`,
+          err.message
+        );
+        poolFailed = true;
+        break;
+      }
+      apiCalls++;
+    }
+    if (poolFailed) break;
+  }
+  return { embedded_count: embedded, skipped_count: 0, duration_ms: Date.now() - start };
+}
+async function enrichPurpose(db, repoId, caps, fullRun = false) {
+  const start = Date.now();
+  if (!caps?.generatePurpose) {
+    return { enriched: 0, skipped: 0, duration_ms: 0 };
+  }
+  let totalEnriched = 0;
+  let totalSkipped = 0;
+  while (true) {
+    const candidates = metadataQueries.getCandidatesForPurpose(db, repoId, PURPOSE_BATCH_LIMIT);
+    if (candidates.length === 0) break;
+    for (let i = 0; i < candidates.length; i += PURPOSE_CONCURRENCY) {
+      const batch = candidates.slice(i, i + PURPOSE_CONCURRENCY);
+      const results = await Promise.allSettled(
+        batch.map(async (row) => {
+          const exports = Array.isArray(row.exports) ? row.exports : jsonParse(row.exports, []);
+          const purpose = await caps.generatePurpose(row.path, row.first_chunk, exports, row.docstring ?? "");
+          return { row, purpose };
+        })
+      );
+      for (let j = 0; j < results.length; j++) {
+        const result = results[j];
+        const row = batch[j];
+        if (result.status === "fulfilled" && result.value.purpose) {
+          metadataQueries.updatePurpose(db, repoId, row.path, result.value.purpose, row.chunk_hash);
+          totalEnriched++;
+        } else {
+          metadataQueries.setPurposeHash(db, repoId, row.path, row.chunk_hash);
+          totalSkipped++;
+        }
+      }
+    }
+    if (!fullRun) break;
+  }
+  return { enriched: totalEnriched, skipped: totalSkipped, duration_ms: Date.now() - start };
+}
+function splitIdentifier(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_\-./\\]/g, " ").toLowerCase().split(/\s+/).filter((w) => w.length >= 3 && !STOPWORDS3.has(w));
+}
+function extractVocab(files) {
+  const termToFiles = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const pathParts = f.path.split("/");
+    for (const seg of pathParts) {
+      const base = seg.replace(/\.[^.]+$/, "");
+      for (const word of splitIdentifier(base)) {
+        const s = termToFiles.get(word) ?? /* @__PURE__ */ new Set();
+        s.add(f.path);
+        termToFiles.set(word, s);
+      }
+    }
+    for (const exp of f.exports) {
+      for (const word of splitIdentifier(exp)) {
+        const s = termToFiles.get(word) ?? /* @__PURE__ */ new Set();
+        s.add(f.path);
+        termToFiles.set(word, s);
+      }
+    }
+  }
+  const totalFiles = files.length;
+  const maxDf = Math.max(10, Math.floor(totalFiles * 0.3));
+  const filtered = [];
+  for (const [term, fileSet] of termToFiles) {
+    if (fileSet.size >= 2 && fileSet.size <= maxDf) {
+      filtered.push(term);
+    }
+  }
+  filtered.sort((a, b) => (termToFiles.get(b)?.size ?? 0) - (termToFiles.get(a)?.size ?? 0));
+  const terms = filtered.slice(0, MAX_TERMS);
+  return { terms, termToFiles };
+}
+function cosine2(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  return denom > 0 ? dot / denom : 0;
+}
+function agglomerativeCluster(terms, embeddings) {
+  const n = terms.length;
+  const pairs = [];
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const sim = cosine2(embeddings[i], embeddings[j]);
+      if (sim >= SIMILARITY_THRESHOLD) pairs.push({ i, j, sim });
+    }
+  }
+  pairs.sort((a, b) => b.sim - a.sim);
+  const parent = new Int32Array(n);
+  const size = new Uint16Array(n);
+  for (let i = 0; i < n; i++) {
+    parent[i] = i;
+    size[i] = 1;
+  }
+  function find(x) {
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  }
+  for (const { i, j } of pairs) {
+    const ri = find(i), rj = find(j);
+    if (ri === rj) continue;
+    if (size[ri] + size[rj] > MAX_CLUSTER_SIZE) continue;
+    if (size[ri] >= size[rj]) {
+      parent[rj] = ri;
+      size[ri] += size[rj];
+    } else {
+      parent[ri] = rj;
+      size[rj] += size[ri];
+    }
+  }
+  const clusterMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const root = find(i);
+    const arr = clusterMap.get(root) ?? [];
+    arr.push(i);
+    clusterMap.set(root, arr);
+  }
+  return [...clusterMap.values()].filter((c) => c.length >= 2);
+}
+async function buildVocabClusters(db, repoId, caps, force = false) {
+  if (!caps?.embedTexts) {
+    console.error("[LENS] Vocab clusters: skipped (no embedTexts capability)");
+    return;
+  }
+  const repo = repoQueries.getById(db, repoId);
+  if (!repo) return;
+  if (!force && repo.last_vocab_cluster_commit && repo.last_vocab_cluster_commit === repo.last_indexed_commit) {
+    console.error("[LENS] Vocab clusters: skipped (unchanged since last build)");
+    return;
+  }
+  const rows = metadataQueries.getByRepo(db, repoId).map((r) => ({
+    path: r.path,
+    exports: Array.isArray(r.exports) ? r.exports : jsonParse(r.exports, [])
+  }));
+  if (rows.length === 0) {
+    console.error("[LENS] Vocab clusters: skipped (no metadata rows)");
+    return;
+  }
+  const { terms, termToFiles } = extractVocab(rows);
+  if (terms.length < 4) {
+    console.error(`[LENS] Vocab clusters: skipped (only ${terms.length} terms, need \u22654)`);
+    return;
+  }
+  console.error(
+    `[LENS] Vocab clusters: embedding ${terms.length} terms in ${Math.ceil(terms.length / TERM_BATCH_SIZE)} batches...`
+  );
+  let embeddings;
+  try {
+    const results = [];
+    for (let i = 0; i < terms.length; i += TERM_BATCH_SIZE) {
+      const batch = terms.slice(i, i + TERM_BATCH_SIZE);
+      const vecs = await caps.embedTexts(batch, false);
+      results.push(...vecs);
+    }
+    embeddings = results;
+  } catch (err) {
+    console.error(`[LENS] Vocab clusters: embed failed (${terms.length} terms):`, err.message);
+    return;
+  }
+  const rawClusters = agglomerativeCluster(terms, embeddings);
+  console.error(`[LENS] Vocab clusters: ${rawClusters.length} clusters from ${terms.length} terms`);
+  const clusters = rawClusters.map((indices) => {
+    const clusterTerms = indices.map((i) => terms[i]);
+    const fileSet = /* @__PURE__ */ new Set();
+    for (const t of clusterTerms) {
+      const files = termToFiles.get(t);
+      if (files) for (const f of files) fileSet.add(f);
+    }
+    return { terms: clusterTerms, files: [...fileSet].sort() };
+  }).filter((c) => c.files.length > 0).sort((a, b) => b.files.length - a.files.length).slice(0, MAX_CLUSTERS);
+  repoQueries.updateVocabClusters(db, repoId, clusters, repo.last_indexed_commit ?? void 0);
+}
+async function handleFileChange(db, repoId, repoRoot, absPath) {
+  const relPath = relative3(repoRoot, absPath);
+  if (isBinaryExt(relPath)) return;
+  try {
+    const s = await stat22(absPath);
+    if (s.size > MAX_FILE_SIZE) return;
+  } catch {
+    return;
+  }
+  let content;
+  try {
+    content = await readFile2(absPath, "utf-8");
+  } catch {
+    return;
+  }
+  const language = detectLanguage(relPath);
+  const newChunks = chunkFile(content, DEFAULT_CHUNKING_PARAMS);
+  const existing = /* @__PURE__ */ new Map();
+  for (const row of chunkQueries.getByRepoPath(db, repoId, relPath)) {
+    existing.set(`${row.chunk_index}:${row.chunk_hash}`, row.id);
+  }
+  const newKeys = /* @__PURE__ */ new Set();
+  for (const chunk of newChunks) {
+    const key = `${chunk.chunk_index}:${chunk.chunk_hash}`;
+    newKeys.add(key);
+    if (existing.has(key)) {
+      chunkQueries.updateLastSeen(db, existing.get(key), repoId, "watcher");
+    } else {
+      chunkQueries.upsert(
+        db,
+        repoId,
+        relPath,
+        chunk.chunk_index,
+        chunk.start_line,
+        chunk.end_line,
+        chunk.content,
+        chunk.chunk_hash,
+        "watcher",
+        language
+      );
+    }
+  }
+  for (const [key, id] of existing) {
+    if (!newKeys.has(key)) chunkQueries.deleteById(db, id, repoId);
+  }
+  const entry = watchers.get(repoId);
+  if (entry) entry.changedFiles++;
+}
+async function handleFileDelete(db, repoId, repoRoot, absPath) {
+  const relPath = relative3(repoRoot, absPath);
+  if (isBinaryExt(relPath)) return;
+  chunkQueries.deleteByRepoPath(db, repoId, relPath);
+  const entry = watchers.get(repoId);
+  if (entry) entry.deletedFiles++;
+}
+function debouncedHandler(key, fn) {
+  const existing = debounceTimers.get(key);
+  if (existing) clearTimeout(existing);
+  debounceTimers.set(
+    key,
+    setTimeout(() => {
+      debounceTimers.delete(key);
+      fn().catch(() => {
+      });
+    }, DEBOUNCE_MS)
+  );
+}
+function startWatcher(db, repoId, rootPath) {
+  if (watchers.has(repoId)) return { started: false, already_watching: true };
+  try {
+    const fsWatcher = watch(rootPath, {
+      ignored: IGNORED,
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 200 },
+      persistent: false,
+      usePolling: false,
+      depth: 5
+    });
+    const entry = {
+      watcher: fsWatcher,
+      repoRoot: rootPath,
+      repoId,
+      changedFiles: 0,
+      deletedFiles: 0,
+      startedAt: /* @__PURE__ */ new Date()
+    };
+    watchers.set(repoId, entry);
+    fsWatcher.on(
+      "add",
+      (path) => debouncedHandler(`${repoId}:${path}`, () => handleFileChange(db, repoId, rootPath, path))
+    );
+    fsWatcher.on(
+      "change",
+      (path) => debouncedHandler(`${repoId}:${path}`, () => handleFileChange(db, repoId, rootPath, path))
+    );
+    fsWatcher.on(
+      "unlink",
+      (path) => debouncedHandler(`${repoId}:${path}`, () => handleFileDelete(db, repoId, rootPath, path))
+    );
+    fsWatcher.on("error", () => {
+      stopWatcher(repoId).catch(() => {
+      });
+    });
+    return { started: true, already_watching: false };
+  } catch {
+    return { started: false, already_watching: false };
+  }
+}
+async function stopWatcher(repoId) {
+  const entry = watchers.get(repoId);
+  if (!entry) return { stopped: false };
+  await entry.watcher.close();
+  watchers.delete(repoId);
+  for (const [key, timer] of debounceTimers) {
+    if (key.startsWith(`${repoId}:`)) {
+      clearTimeout(timer);
+      debounceTimers.delete(key);
+    }
+  }
+  return { stopped: true };
+}
+function getWatcherStatus(repoId) {
+  const entry = watchers.get(repoId);
+  if (!entry) return { watching: false, repo_root: null, changed_files: 0, deleted_files: 0, started_at: null };
+  return {
+    watching: true,
+    repo_root: entry.repoRoot,
+    changed_files: entry.changedFiles,
+    deleted_files: entry.deletedFiles,
+    started_at: entry.startedAt.toISOString()
+  };
+}
+function normalizeRemoteUrl(url) {
+  let normalized = url.trim();
+  const sshMatch = normalized.match(/^[\w-]+@([\w.-]+):(.+)$/);
+  if (sshMatch) {
+    normalized = `${sshMatch[1]}/${sshMatch[2]}`;
+  } else {
+    normalized = normalized.replace(/^https?:\/\//, "");
+  }
+  normalized = normalized.replace(/\.git$/, "");
+  normalized = normalized.replace(/\/$/, "");
+  return normalized.toLowerCase();
+}
+function deriveIdentityKey(rootPath, remoteUrl) {
+  const source = remoteUrl ? normalizeRemoteUrl(remoteUrl) : rootPath;
+  return createHash2("sha256").update(source).digest("hex");
+}
+function registerRepo(db, rootPath, name, remoteUrl) {
+  const identityKey = deriveIdentityKey(rootPath, remoteUrl);
+  const repoName = name ?? rootPath.split("/").pop() ?? "unknown";
+  const { id, created } = repoQueries.upsert(db, identityKey, repoName, rootPath, remoteUrl ?? null);
+  return { repo_id: id, identity_key: identityKey, name: repoName, created };
+}
+function getRepo(db, id) {
+  const repo = repoQueries.getById(db, id);
+  if (!repo) throw new Error("repo not found");
+  return repo;
+}
+function listRepos(db) {
+  return repoQueries.list(db);
+}
+function removeRepo(db, id) {
+  const chunkCount = chunkQueries.countByRepo(db, id);
+  const deleted = repoQueries.remove(db, id);
+  if (!deleted) throw new Error("repo not found");
+  return { deleted: true, chunks_removed: chunkCount };
+}
+async function getRepoStatus(db, id) {
+  const repo = repoQueries.getById(db, id);
+  if (!repo) throw new Error("repo not found");
+  let currentHead = null;
+  try {
+    currentHead = await getHeadCommit(repo.root_path);
   } catch {
-    return {
-      context_pack: `# ${goal}
-
-Context generation failed.`,
-      stats: { files_in_context: 0, index_fresh: false, duration_ms: Date.now() - start, cached: false }
-    };
   }
+  const isStale = !!(currentHead && repo.last_indexed_commit !== currentHead);
+  const stats = chunkQueries.getStats(db, id);
+  const structural = metadataQueries.getStructuralStats(db, id);
+  const vocabRaw = repo.vocab_clusters;
+  const vocabClusters = vocabRaw ? JSON.parse(vocabRaw) : [];
+  return {
+    index_status: repo.index_status,
+    indexed_commit: repo.last_indexed_commit,
+    current_head: currentHead,
+    is_stale: isStale,
+    chunk_count: stats.chunk_count,
+    files_indexed: stats.files_indexed,
+    embedded_count: stats.embedded_count,
+    embeddable_count: stats.embeddable_count,
+    embedded_pct: stats.embeddable_count > 0 ? Math.round(stats.embedded_count / stats.embeddable_count * 100) : 0,
+    metadata_count: structural.metadata_count,
+    import_edge_count: structural.import_edge_count,
+    git_commits_analyzed: structural.git_file_count,
+    cochange_pairs: structural.cochange_pairs,
+    purpose_count: structural.purpose_count,
+    purpose_total: structural.purpose_total,
+    vocab_cluster_count: Array.isArray(vocabClusters) ? vocabClusters.length : 0
+  };
 }
-var __defProp2, __getOwnPropNames2, __esm2, __export2, schema_exports, uuid, now, updatedAt, repos, chunks, fileMetadata, fileImports, fileStats, fileCochanges, usageCounters, requestLogs, settings, telemetryEvents, init_schema, queries_exports, repoQueries, chunkQueries, metadataQueries, importQueries, statsQueries, cochangeQueries, logQueries, usageQueries, telemetryQueries, settingsQueries, init_queries, _db, _raw, execFileAsync, MAX_FILE_SIZE, BINARY_EXTENSIONS, DOCS_EXTENSIONS, LANG_MAP, DEFAULT_CHUNKING_PARAMS, TS_IMPORT_RE, PY_IMPORT_RE, GO_IMPORT_RE, RUST_USE_RE, TS_EXTENSIONS, PY_EXTENSIONS, TS_EXPORT_RE, PY_EXPORT_RE, GO_EXPORT_RE, RUST_EXPORT_RE, CSHARP_EXPORT_RE, CSHARP_EXPORT_METHOD_RE, JAVA_EXPORT_RE, JSDOC_RE, PY_DOCSTRING_RE, CSHARP_DOC_RE, GO_PKG_RE, RUST_DOC_RE, SECTION_SINGLE_RE, SECTION_BLOCK_RE, UNIVERSAL_DECL_RES, EXPORT_LINE_RE, SKIP_NAMES, execFileAsync2, MAX_COMMITS, MAX_FILES_PER_COMMIT, RECENT_DAYS, _enabled, MAX_CHUNKS_PER_REPO, locks, MAX_API_CALLS, POOL_SIZE, MAX_BATCH_TOKENS, CHARS_PER_TOKEN, PURPOSE_BATCH_LIMIT, PURPOSE_CONCURRENCY, TERM_BATCH_SIZE, SIMILARITY_THRESHOLD, MAX_TERMS, MAX_CLUSTERS, MAX_CLUSTER_SIZE, STOPWORDS, watchers, debounceTimers, IGNORED, DEBOUNCE_MS, STOPWORDS2, NOISE_EXTENSIONS, NOISE_PATHS, CONCEPT_SYNONYMS, CACHE_TTL, CACHE_MAX, cache, RequestTrace;
+var __defProp2, __getOwnPropNames2, __esm2, __export2, schema_exports, uuid, now, updatedAt, repos, chunks, fileMetadata, fileImports, fileStats, fileCochanges, usageCounters, requestLogs, settings, telemetryEvents, init_schema, queries_exports, repoQueries, chunkQueries, metadataQueries, importQueries, statsQueries, cochangeQueries, logQueries, usageQueries, telemetryQueries, settingsQueries, init_queries, slicer_exports, RADIUS, MAX_SLICES, init_slicer, _enabled, DEFAULT_CHUNKING_PARAMS, execFileAsync, MAX_FILE_SIZE, BINARY_EXTENSIONS, DOCS_EXTENSIONS, LANG_MAP, TS_IMPORT_RE, PY_IMPORT_RE, GO_IMPORT_RE, RUST_USE_RE, TS_EXTENSIONS, PY_EXTENSIONS, TS_EXPORT_RE, PY_EXPORT_RE, GO_EXPORT_RE, RUST_EXPORT_RE, CSHARP_EXPORT_RE, CSHARP_EXPORT_METHOD_RE, JAVA_EXPORT_RE, JSDOC_RE, PY_DOCSTRING_RE, CSHARP_DOC_RE, GO_PKG_RE, RUST_DOC_RE, SECTION_SINGLE_RE, SECTION_BLOCK_RE, UNIVERSAL_DECL_RES, EXPORT_LINE_RE, SKIP_NAMES, execFileAsync2, MAX_COMMITS, MAX_FILES_PER_COMMIT, RECENT_DAYS, MAX_CHUNKS_PER_REPO, locks, TOKEN_CAP, LANG_EXT, FRAME_PATTERNS, CASING_BOUNDARY, SYMBOL_RE, ERROR_CODE_RE, ERROR_SUFFIX_RE, ERROR_PREFIX_RE, STOPWORDS, STOPWORDS2, NOISE_EXTENSIONS, NOISE_PATHS, CONCEPT_SYNONYMS, SYMBOL_DEF_RE, TEST_PATTERN, CACHE_TTL, CACHE_MAX, cache, _db, _raw, GOLD_DATASET, MAX_API_CALLS, POOL_SIZE, MAX_BATCH_TOKENS, CHARS_PER_TOKEN, PURPOSE_BATCH_LIMIT, PURPOSE_CONCURRENCY, TERM_BATCH_SIZE, SIMILARITY_THRESHOLD, MAX_TERMS, MAX_CLUSTERS, MAX_CLUSTER_SIZE, STOPWORDS3, watchers, debounceTimers, IGNORED, DEBOUNCE_MS, RequestTrace;
 var init_dist = __esm({
   "packages/engine/dist/index.js"() {
     "use strict";
@@ -9771,10 +10444,7 @@ var init_dist = __esm({
             created_at: now(),
             synced_at: text("synced_at")
           },
-          (t) => [
-            index("idx_telemetry_events_type").on(t.event_type),
-            index("idx_telemetry_events_synced").on(t.synced_at)
-          ]
+          (t) => [index("idx_telemetry_events_type").on(t.event_type), index("idx_telemetry_events_synced").on(t.synced_at)]
         );
       }
     });
@@ -9972,6 +10642,21 @@ var init_dist = __esm({
             const row = db.select({ id: chunks.id }).from(chunks).where(and(eq(chunks.repo_id, repoId), sql`embedding IS NOT NULL`)).limit(1).get();
             return !!row;
           },
+          getByRepoPaths(db, repoId, paths) {
+            if (!paths.length) return [];
+            return db.select({
+              path: chunks.path,
+              chunk_index: chunks.chunk_index,
+              start_line: chunks.start_line,
+              end_line: chunks.end_line,
+              content: chunks.content
+            }).from(chunks).where(and(eq(chunks.repo_id, repoId), inArray(chunks.path, paths))).orderBy(chunks.path, chunks.chunk_index).all();
+          },
+          searchContent(db, repoId, searchString) {
+            if (!searchString || searchString.length < 4) return [];
+            const rows = db.select({ path: chunks.path }).from(chunks).where(and(eq(chunks.repo_id, repoId), sql`INSTR(LOWER(${chunks.content}), ${searchString.toLowerCase()}) > 0`)).groupBy(chunks.path).all();
+            return rows.map((r) => r.path);
+          },
           getStats(db, repoId) {
             const row = db.select({
               chunk_count: sql`count(*)`,
@@ -10222,7 +10907,7 @@ var init_dist = __esm({
             const { limit = 50, offset = 0, method, path, status, source } = opts;
             const conditions = [];
             if (method) conditions.push(eq(requestLogs.method, method));
-            if (path) conditions.push(sql`${requestLogs.path} LIKE ${"%" + path + "%"}`);
+            if (path) conditions.push(sql`${requestLogs.path} LIKE ${`%${path}%`}`);
             if (status) conditions.push(eq(requestLogs.status, status));
             if (source) conditions.push(eq(requestLogs.source, source));
             const where = conditions.length ? and(...conditions) : void 0;
@@ -10264,7 +10949,9 @@ var init_dist = __esm({
             return db.select().from(usageCounters).where(eq(usageCounters.date, date3)).get() ?? null;
           },
           getUnsynced(db) {
-            return db.select().from(usageCounters).where(sql`synced_at IS NULL AND (context_queries > 0 OR embedding_requests > 0 OR purpose_requests > 0 OR repos_indexed > 0)`).all();
+            return db.select().from(usageCounters).where(
+              sql`synced_at IS NULL AND (context_queries > 0 OR embedding_requests > 0 OR purpose_requests > 0 OR repos_indexed > 0)`
+            ).all();
           },
           markSynced(db, date3) {
             db.update(usageCounters).set({ synced_at: sql`datetime('now')` }).where(eq(usageCounters.date, date3)).run();
@@ -10316,10 +11003,32 @@ var init_dist = __esm({
         };
       }
     });
-    init_schema();
-    _db = null;
-    _raw = null;
+    slicer_exports = {};
+    __export2(slicer_exports, {
+      sliceContext: () => sliceContext
+    });
+    init_slicer = __esm2({
+      "src/context/slicer.ts"() {
+        "use strict";
+        init_queries();
+        RADIUS = 10;
+        MAX_SLICES = {
+          symbol: 1,
+          error_message: 1,
+          stack_trace: 2,
+          natural: 3
+        };
+      }
+    });
+    init_queries();
     init_queries();
+    init_queries();
+    _enabled = true;
+    DEFAULT_CHUNKING_PARAMS = {
+      target_lines: 150,
+      overlap_lines: 10,
+      version: 1
+    };
     execFileAsync = promisify(execFile);
     MAX_FILE_SIZE = 2 * 1024 * 1024;
     BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -10397,12 +11106,6 @@ var init_dist = __esm({
       ".scss": "scss"
     };
     init_queries();
-    DEFAULT_CHUNKING_PARAMS = {
-      target_lines: 150,
-      overlap_lines: 10,
-      version: 1
-    };
-    init_queries();
     TS_IMPORT_RE = /(?:import\s+.*?from\s+|import\s+|export\s+.*?from\s+|require\s*\()['"]([^'"]+)['"]/g;
     PY_IMPORT_RE = /^(?:from\s+(\.[\w.]*)\s+import|import\s+([\w.]+))/gm;
     GO_IMPORT_RE = /import\s+(?:\(\s*)?(?:[\w.]*\s+)?"([^"]+)"/g;
@@ -10414,7 +11117,7 @@ var init_dist = __esm({
     GO_EXPORT_RE = /^func\s+([A-Z]\w*)/gm;
     RUST_EXPORT_RE = /^pub\s+(?:fn|struct|enum|trait|type|mod)\s+(\w+)/gm;
     CSHARP_EXPORT_RE = /^\s*(?:public|internal)\s+(?:static\s+)?(?:abstract\s+|sealed\s+|partial\s+)?(?:class|interface|enum|struct|record|delegate)\s+(\w+)/gm;
-    CSHARP_EXPORT_METHOD_RE = /^\s*public\s+(?:static\s+)?(?:async\s+)?(?:override\s+)?(?:virtual\s+)?[\w<>\[\]?.]+\s+(\w+)\s*\(/gm;
+    CSHARP_EXPORT_METHOD_RE = /^\s*public\s+(?:static\s+)?(?:async\s+)?(?:override\s+)?(?:virtual\s+)?[\w<>[\]?.]+\s+(\w+)\s*\(/gm;
     JAVA_EXPORT_RE = /^\s*(?:public)\s+(?:static\s+)?(?:abstract\s+|final\s+)?(?:class|interface|enum|record)\s+(\w+)/gm;
     JSDOC_RE = /^\/\*\*\s*([\s\S]*?)\*\//m;
     PY_DOCSTRING_RE = /^(?:["']{3})([\s\S]*?)(?:["']{3})/m;
@@ -10428,60 +11131,179 @@ var init_dist = __esm({
       /^\s*(?:const|let|var|val)\s+(\w+)\s*[=:]/gm,
       /^\s*(?:abstract\s+|sealed\s+|partial\s+|data\s+)?(?:class|struct|enum|trait|interface|record|object|mod)\s+(\w+)/gm,
       /^\s*type\s+(\w+)\s*[=<{]/gm,
-      /^\s*(?:private|protected|internal)\s+(?:static\s+)?(?:async\s+)?(?:suspend\s+)?(?:override\s+)?[\w<>\[\]?.]+\s+(\w+)\s*\(/gm
+      /^\s*(?:private|protected|internal)\s+(?:static\s+)?(?:async\s+)?(?:suspend\s+)?(?:override\s+)?[\w<>[\]?.]+\s+(\w+)\s*\(/gm
     ];
     EXPORT_LINE_RE = /^(?:export|pub\s|public\s)/;
     SKIP_NAMES = /* @__PURE__ */ new Set([
       "if",
-      "for",
-      "foreach",
-      "while",
-      "switch",
-      "using",
-      "catch",
-      "lock",
-      "return",
-      "throw",
-      "yield",
-      "try",
-      "do",
-      "else",
-      "new",
-      "await",
-      "base",
+      "for",
+      "foreach",
+      "while",
+      "switch",
+      "using",
+      "catch",
+      "lock",
+      "return",
+      "throw",
+      "yield",
+      "try",
+      "do",
+      "else",
+      "new",
+      "await",
+      "base",
+      "this",
+      "super",
+      "self",
+      "import",
+      "require",
+      "from",
+      "package"
+    ]);
+    init_queries();
+    execFileAsync2 = promisify2(execFile2);
+    MAX_COMMITS = 2e3;
+    MAX_FILES_PER_COMMIT = 20;
+    RECENT_DAYS = 90;
+    init_queries();
+    MAX_CHUNKS_PER_REPO = 1e5;
+    locks = /* @__PURE__ */ new Map();
+    TOKEN_CAP = 2e3;
+    LANG_EXT = {
+      ts: "typescript",
+      tsx: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      py: "python",
+      rb: "ruby",
+      go: "go",
+      rs: "rust",
+      java: "java",
+      kt: "kotlin",
+      cs: "csharp",
+      cpp: "cpp",
+      c: "c",
+      h: "c",
+      swift: "swift",
+      php: "php",
+      sql: "sql",
+      sh: "shell"
+    };
+    FRAME_PATTERNS = [
+      // JS/TS: at fn (path:line:col) or at path:line:col
+      /at\s+(?:\S+\s+\()?([^():]+):(\d+):\d+\)?/g,
+      // Python: File "path", line N
+      /File\s+"([^"]+)",\s+line\s+(\d+)/g,
+      // C#/Java: at namespace(path:line)
+      /at\s+\S+\(([^():]+):(\d+)\)/g
+    ];
+    CASING_BOUNDARY = /[a-z][A-Z]|_/;
+    SYMBOL_RE = /^[a-zA-Z_]\w+$/;
+    ERROR_CODE_RE = /\b[A-Z][A-Z0-9_]{2,}\b/;
+    ERROR_SUFFIX_RE = /\w+(Exception|Error)\b/;
+    ERROR_PREFIX_RE = /\b(TypeError|ReferenceError|SyntaxError|RangeError|Error|panic|FATAL|WARN|ERR):/;
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "being",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "might",
+      "can",
+      "need",
+      "must",
+      "to",
+      "of",
+      "in",
+      "for",
+      "on",
+      "with",
+      "at",
+      "by",
+      "from",
+      "as",
+      "into",
+      "through",
+      "and",
+      "but",
+      "or",
+      "not",
+      "no",
+      "so",
+      "if",
+      "then",
+      "than",
+      "that",
       "this",
-      "super",
-      "self",
+      "it",
+      "its",
+      "all",
+      "each",
+      "every",
+      "any",
+      "some",
+      "how",
+      "what",
+      "which",
+      "who",
+      "when",
+      "where",
+      "why",
+      "get",
+      "set",
+      "new",
+      "null",
+      "true",
+      "false",
+      "void",
+      "type",
+      "var",
+      "let",
+      "const",
+      "return",
       "import",
-      "require",
-      "from",
-      "package"
+      "export",
+      "default",
+      "class",
+      "function",
+      "string",
+      "number",
+      "boolean",
+      "object",
+      "array",
+      "index",
+      "data",
+      "value",
+      "result",
+      "item",
+      "list",
+      "name",
+      "id",
+      "key",
+      "src",
+      "lib",
+      "app",
+      "spec",
+      "mock",
+      "module"
     ]);
-    init_queries();
-    init_queries();
-    execFileAsync2 = promisify2(execFile2);
-    MAX_COMMITS = 2e3;
-    MAX_FILES_PER_COMMIT = 20;
-    RECENT_DAYS = 90;
-    init_queries();
-    _enabled = true;
-    MAX_CHUNKS_PER_REPO = 1e5;
-    locks = /* @__PURE__ */ new Map();
-    init_queries();
-    MAX_API_CALLS = 2e3;
-    POOL_SIZE = 32;
-    MAX_BATCH_TOKENS = 1e5;
-    CHARS_PER_TOKEN = 3;
-    init_queries();
-    PURPOSE_BATCH_LIMIT = 200;
-    PURPOSE_CONCURRENCY = 10;
-    init_queries();
-    TERM_BATCH_SIZE = 32;
-    SIMILARITY_THRESHOLD = 0.75;
-    MAX_TERMS = 1500;
-    MAX_CLUSTERS = 200;
-    MAX_CLUSTER_SIZE = 12;
-    STOPWORDS = /* @__PURE__ */ new Set([
+    STOPWORDS2 = /* @__PURE__ */ new Set([
       "the",
       "a",
       "an",
@@ -10578,39 +11400,294 @@ var init_dist = __esm({
       "src",
       "lib",
       "app",
-      "test",
       "spec",
       "mock",
-      "model",
       "module",
-      "component"
+      "work",
+      "works",
+      "working",
+      "make",
+      "makes",
+      "use",
+      "uses",
+      "used",
+      "using",
+      "find",
+      "run",
+      "runs",
+      "call",
+      "calls",
+      "look",
+      "like",
+      "just",
+      "also",
+      "about",
+      "there",
+      "here",
+      "define",
+      "defined",
+      "handle",
+      "handles",
+      "add",
+      "adds",
+      "create",
+      "serve",
+      "does",
+      "file",
+      "files"
+    ]);
+    NOISE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".md",
+      ".json",
+      ".yaml",
+      ".yml",
+      ".toml",
+      ".lock",
+      ".sql",
+      ".txt",
+      ".csv",
+      ".psd",
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".svg",
+      ".ico",
+      ".woff",
+      ".woff2",
+      ".ttf",
+      ".eot",
+      ".xml",
+      ".axml",
+      ".resx",
+      ".config"
     ]);
+    NOISE_PATHS = [
+      ".gitignore",
+      ".github/",
+      ".vscode/",
+      ".idea/",
+      "node_modules/",
+      "dist/",
+      "build/",
+      "publish/",
+      "vendor/",
+      "vendors/",
+      "/scripts/",
+      "areas/helppage/",
+      "packages.config",
+      "resources/drawable/",
+      "resources/layout/",
+      "resources/values/",
+      "wwwroot/lib/",
+      "wwwroot/css/",
+      "wwwroot/js/lib/",
+      ".min.js",
+      ".min.css",
+      ".designer.cs",
+      "assemblyinfo.cs"
+    ];
+    CONCEPT_SYNONYMS = {
+      error: ["interceptor", "exception", "catch", "middleware", "handler"],
+      errors: ["interceptor", "exception", "catch", "middleware", "handler"],
+      retry: ["interceptor", "backoff", "retry", "queue"],
+      retries: ["interceptor", "backoff", "retry", "queue"],
+      auth: ["interceptor", "token", "login", "guard", "middleware", "session"],
+      authentication: ["interceptor", "token", "login", "guard", "middleware"],
+      authorization: ["guard", "role", "permission", "policy"],
+      cache: ["invalidat", "ttl", "expire", "store", "memo"],
+      caching: ["invalidat", "ttl", "expire", "store", "memo"],
+      logging: ["logger", "trace", "monitor", "telemetry"],
+      validation: ["validator", "schema", "sanitiz", "constraint"],
+      notification: ["email", "alert", "signal", "push", "webhook"],
+      upload: ["multipart", "stream", "blob", "attachment", "photo"],
+      performance: ["optimize", "cache", "lazy", "batch", "throttle"],
+      security: ["auth", "token", "encrypt", "cors", "csrf", "sanitiz"],
+      testing: ["spec", "mock", "fixture", "assert", "stub"],
+      deploy: ["pipeline", "docker", "build", "release", "ci-cd"],
+      database: ["repository", "migration", "query", "schema", "orm"],
+      api: ["controller", "endpoint", "route", "middleware", "interceptor"]
+    };
     init_queries();
-    watchers = /* @__PURE__ */ new Map();
-    debounceTimers = /* @__PURE__ */ new Map();
-    IGNORED = [
-      /(^|[/\\])\../,
-      "**/node_modules/**",
-      "**/.git/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/__pycache__/**",
-      "**/target/**",
-      "**/.next/**",
-      "**/.nuxt/**",
-      "**/coverage/**",
-      "**/.turbo/**",
-      "**/out/**",
-      "**/.output/**",
-      "**/*.log",
-      "**/*.lock",
-      "**/pnpm-lock.yaml",
-      "**/package-lock.json",
-      "**/yarn.lock"
+    SYMBOL_DEF_RE = /^.*?\b(?:function|def|fn|class|const|let|var|type|interface|struct|enum|export\s+(?:function|class|const|type|interface|default))\s+/;
+    init_queries();
+    TEST_PATTERN = /\.(?:test|spec)\.|__tests__\/|_test\./;
+    init_queries();
+    CACHE_TTL = 12e4;
+    CACHE_MAX = 20;
+    cache = /* @__PURE__ */ new Map();
+    init_schema();
+    _db = null;
+    _raw = null;
+    init_queries();
+    GOLD_DATASET = [
+      // --- natural (12) ---
+      {
+        id: "nat-01",
+        query: "How does the context pack pipeline work?",
+        kind: "natural",
+        expected_files: [
+          "packages/engine/src/context/context.ts",
+          "packages/engine/src/context/formatter.ts",
+          "packages/engine/src/context/query-interpreter.ts"
+        ],
+        expected_entry: "packages/engine/src/context/context.ts"
+      },
+      {
+        id: "nat-02",
+        query: "How does file indexing work?",
+        kind: "natural",
+        expected_files: [
+          "packages/engine/src/index/engine.ts",
+          "packages/engine/src/index/chunker.ts",
+          "packages/engine/src/index/discovery.ts"
+        ],
+        expected_entry: "packages/engine/src/index/engine.ts"
+      },
+      {
+        id: "nat-03",
+        query: "How are imports resolved and the import graph built?",
+        kind: "natural",
+        expected_files: ["packages/engine/src/index/import-graph.ts", "packages/engine/src/index/imports.ts"],
+        expected_entry: "packages/engine/src/index/import-graph.ts"
+      },
+      {
+        id: "nat-04",
+        query: "How does the daemon HTTP server handle requests?",
+        kind: "natural",
+        expected_files: ["apps/daemon/src/server.ts", "apps/daemon/src/index.ts"],
+        expected_entry: "apps/daemon/src/server.ts"
+      },
+      {
+        id: "nat-05",
+        query: "How does the CLI register a repo?",
+        kind: "natural",
+        expected_files: ["packages/cli/src/commands/register.ts", "packages/engine/src/repo/repo.ts"],
+        expected_entry: "packages/cli/src/commands/register.ts"
+      },
+      {
+        id: "nat-06",
+        query: "How does git history analysis and co-change detection work?",
+        kind: "natural",
+        expected_files: ["packages/engine/src/index/git-analysis.ts"],
+        expected_entry: "packages/engine/src/index/git-analysis.ts"
+      },
+      {
+        id: "nat-07",
+        query: "How does the MCP stdio server work?",
+        kind: "natural",
+        expected_files: ["apps/daemon/src/mcp.ts"],
+        expected_entry: "apps/daemon/src/mcp.ts"
+      },
+      {
+        id: "nat-08",
+        query: "How does TF-IDF scoring work in the query interpreter?",
+        kind: "natural",
+        expected_files: ["packages/engine/src/context/query-interpreter.ts"],
+        expected_entry: "packages/engine/src/context/query-interpreter.ts"
+      },
+      {
+        id: "nat-09",
+        query: "How are file metadata (exports, docstrings, sections) extracted?",
+        kind: "natural",
+        expected_files: ["packages/engine/src/index/extract-metadata.ts"],
+        expected_entry: "packages/engine/src/index/extract-metadata.ts"
+      },
+      {
+        id: "nat-10",
+        query: "How does vector/semantic search work?",
+        kind: "natural",
+        expected_files: ["packages/engine/src/context/vector.ts", "packages/engine/src/index/embed.ts"],
+        expected_entry: "packages/engine/src/context/vector.ts"
+      },
+      {
+        id: "nat-11",
+        query: "How does the file watcher detect changes?",
+        kind: "natural",
+        expected_files: ["packages/engine/src/index/watcher.ts"],
+        expected_entry: "packages/engine/src/index/watcher.ts"
+      },
+      {
+        id: "nat-12",
+        query: "How is the database schema defined?",
+        kind: "natural",
+        expected_files: ["packages/engine/src/db/schema.ts", "packages/engine/src/db/connection.ts"],
+        expected_entry: "packages/engine/src/db/schema.ts"
+      },
+      // --- symbol (5) ---
+      {
+        id: "sym-01",
+        query: "buildContext",
+        kind: "symbol",
+        expected_files: ["packages/engine/src/context/context.ts"],
+        expected_entry: "packages/engine/src/context/context.ts"
+      },
+      {
+        id: "sym-02",
+        query: "interpretQuery",
+        kind: "symbol",
+        expected_files: ["packages/engine/src/context/query-interpreter.ts"],
+        expected_entry: "packages/engine/src/context/query-interpreter.ts"
+      },
+      {
+        id: "sym-03",
+        query: "runIndex",
+        kind: "symbol",
+        expected_files: ["packages/engine/src/index/engine.ts"],
+        expected_entry: "packages/engine/src/index/engine.ts"
+      },
+      {
+        id: "sym-04",
+        query: "extractFileMetadata",
+        kind: "symbol",
+        expected_files: ["packages/engine/src/index/extract-metadata.ts"],
+        expected_entry: "packages/engine/src/index/extract-metadata.ts"
+      },
+      {
+        id: "sym-05",
+        query: "formatContextPack",
+        kind: "symbol",
+        expected_files: ["packages/engine/src/context/formatter.ts"],
+        expected_entry: "packages/engine/src/context/formatter.ts"
+      },
+      // --- error_message (3) ---
+      {
+        id: "err-01",
+        query: "Error: repo not found",
+        kind: "error_message",
+        expected_files: ["packages/engine/src/repo/repo.ts", "apps/daemon/src/server.ts"],
+        expected_entry: "packages/engine/src/repo/repo.ts"
+      },
+      {
+        id: "err-02",
+        query: "LENS daemon is not running",
+        kind: "error_message",
+        expected_files: ["packages/cli/src/util/client.ts"],
+        expected_entry: "packages/cli/src/util/client.ts"
+      },
+      {
+        id: "err-03",
+        query: "Context generation failed",
+        kind: "error_message",
+        expected_files: ["packages/engine/src/context/context.ts"],
+        expected_entry: "packages/engine/src/context/context.ts"
+      }
     ];
-    DEBOUNCE_MS = 500;
     init_queries();
-    STOPWORDS2 = /* @__PURE__ */ new Set([
+    MAX_API_CALLS = 2e3;
+    POOL_SIZE = 32;
+    MAX_BATCH_TOKENS = 1e5;
+    CHARS_PER_TOKEN = 3;
+    init_queries();
+    PURPOSE_BATCH_LIMIT = 200;
+    PURPOSE_CONCURRENCY = 10;
+    init_queries();
+    TERM_BATCH_SIZE = 32;
+    SIMILARITY_THRESHOLD = 0.75;
+    MAX_TERMS = 1500;
+    MAX_CLUSTERS = 200;
+    MAX_CLUSTER_SIZE = 12;
+    STOPWORDS3 = /* @__PURE__ */ new Set([
       "the",
       "a",
       "an",
@@ -10707,86 +11784,37 @@ var init_dist = __esm({
       "src",
       "lib",
       "app",
+      "test",
       "spec",
       "mock",
-      "module"
-    ]);
-    NOISE_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".md",
-      ".json",
-      ".yaml",
-      ".yml",
-      ".toml",
-      ".lock",
-      ".sql",
-      ".txt",
-      ".csv",
-      ".psd",
-      ".png",
-      ".jpg",
-      ".jpeg",
-      ".gif",
-      ".svg",
-      ".ico",
-      ".woff",
-      ".woff2",
-      ".ttf",
-      ".eot",
-      ".xml",
-      ".axml",
-      ".resx",
-      ".config"
+      "model",
+      "module",
+      "component"
     ]);
-    NOISE_PATHS = [
-      ".gitignore",
-      ".github/",
-      ".vscode/",
-      ".idea/",
-      "node_modules/",
-      "dist/",
-      "build/",
-      "vendor/",
-      "vendors/",
-      "/scripts/",
-      "areas/helppage/",
-      "packages.config",
-      "resources/drawable/",
-      "resources/layout/",
-      "resources/values/",
-      "wwwroot/lib/",
-      "wwwroot/css/",
-      "wwwroot/js/lib/",
-      ".min.js",
-      ".min.css",
-      ".designer.cs",
-      "assemblyinfo.cs"
-    ];
-    CONCEPT_SYNONYMS = {
-      error: ["interceptor", "exception", "catch", "middleware", "handler"],
-      errors: ["interceptor", "exception", "catch", "middleware", "handler"],
-      retry: ["interceptor", "backoff", "retry", "queue"],
-      retries: ["interceptor", "backoff", "retry", "queue"],
-      auth: ["interceptor", "token", "login", "guard", "middleware", "session"],
-      authentication: ["interceptor", "token", "login", "guard", "middleware"],
-      authorization: ["guard", "role", "permission", "policy"],
-      cache: ["invalidat", "ttl", "expire", "store", "memo"],
-      caching: ["invalidat", "ttl", "expire", "store", "memo"],
-      logging: ["logger", "trace", "monitor", "telemetry"],
-      validation: ["validator", "schema", "sanitiz", "constraint"],
-      notification: ["email", "alert", "signal", "push", "webhook"],
-      upload: ["multipart", "stream", "blob", "attachment", "photo"],
-      performance: ["optimize", "cache", "lazy", "batch", "throttle"],
-      security: ["auth", "token", "encrypt", "cors", "csrf", "sanitiz"],
-      testing: ["spec", "mock", "fixture", "assert", "stub"],
-      deploy: ["pipeline", "docker", "build", "release", "ci-cd"],
-      database: ["repository", "migration", "query", "schema", "orm"],
-      api: ["controller", "endpoint", "route", "middleware", "interceptor"]
-    };
-    init_queries();
     init_queries();
-    CACHE_TTL = 12e4;
-    CACHE_MAX = 20;
-    cache = /* @__PURE__ */ new Map();
+    watchers = /* @__PURE__ */ new Map();
+    debounceTimers = /* @__PURE__ */ new Map();
+    IGNORED = [
+      /(^|[/\\])\../,
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/__pycache__/**",
+      "**/target/**",
+      "**/.next/**",
+      "**/.nuxt/**",
+      "**/coverage/**",
+      "**/.turbo/**",
+      "**/out/**",
+      "**/.output/**",
+      "**/*.log",
+      "**/*.lock",
+      "**/pnpm-lock.yaml",
+      "**/package-lock.json",
+      "**/yarn.lock"
+    ];
+    DEBOUNCE_MS = 500;
     init_queries();
     RequestTrace = class {
       steps = [];
@@ -10822,10 +11850,10 @@ var init_dist = __esm({
 });
 
 // apps/daemon/src/config.ts
-import { readFileSync, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join4, dirname as dirname3 } from "path";
-import { homedir as homedir2 } from "os";
 import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, join as join4 } from "path";
 function readConfig() {
   try {
     return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
@@ -10876,31 +11904,45 @@ var cloud_capabilities_exports = {};
 __export(cloud_capabilities_exports, {
   createCloudCapabilities: () => createCloudCapabilities
 });
-function createCloudCapabilities(apiKey, trackUsage, logRequest) {
+function createCloudCapabilities(getKey, refreshKey, trackUsage, logRequest) {
   const CLOUD_API_URL = getCloudUrl();
-  const headers = {
-    Authorization: `Bearer ${apiKey}`,
-    "Content-Type": "application/json"
-  };
+  async function cloudFetch(path, reqBody) {
+    const apiKey = await getKey();
+    if (!apiKey) throw new Error("No API key available");
+    const start = performance.now();
+    let res = await fetch(`${CLOUD_API_URL}${path}`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      body: reqBody
+    });
+    let resText = await res.text();
+    let duration3 = Math.round(performance.now() - start);
+    logRequest?.("POST", path, res.status, duration3, "cloud", reqBody, resText);
+    if (res.status === 401) {
+      const newKey = await refreshKey();
+      if (newKey) {
+        const retryStart = performance.now();
+        res = await fetch(`${CLOUD_API_URL}${path}`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${newKey}`, "Content-Type": "application/json" },
+          body: reqBody
+        });
+        resText = await res.text();
+        duration3 = Math.round(performance.now() - retryStart);
+        logRequest?.("POST", path, res.status, duration3, "cloud-retry", reqBody, resText);
+      }
+    }
+    return { res, resText };
+  }
   return {
     async embedTexts(texts, isQuery) {
-      const start = performance.now();
       const reqBody = JSON.stringify({
         input: texts,
         model: "voyage-code-3",
         input_type: isQuery ? "query" : "document"
       });
-      const res = await fetch(`${CLOUD_API_URL}/api/proxy/embed`, {
-        method: "POST",
-        headers,
-        body: reqBody
-      });
-      const resText = await res.text();
-      const duration3 = Math.round(performance.now() - start);
-      logRequest?.("POST", "/api/proxy/embed", res.status, duration3, "cloud", reqBody, resText);
-      if (!res.ok) {
-        throw new Error(`Cloud embed failed (${res.status}): ${resText}`);
-      }
+      const { res, resText } = await cloudFetch("/api/proxy/embed", reqBody);
+      if (!res.ok) throw new Error(`Cloud embed failed (${res.status}): ${resText}`);
       const data = JSON.parse(resText);
       trackUsage?.("embedding_requests");
       trackUsage?.("embedding_chunks", texts.length);
@@ -10914,25 +11956,18 @@ function createCloudCapabilities(apiKey, trackUsage, logRequest) {
         "",
         content.slice(0, 2e3)
       ].filter(Boolean).join("\n");
-      const start = performance.now();
       const reqBody = JSON.stringify({
         messages: [
-          { role: "system", content: "You are a code analyst. Output ONLY a 1-sentence purpose summary for the given file. No preamble." },
+          {
+            role: "system",
+            content: "You are a code analyst. Output ONLY a 1-sentence purpose summary for the given file. No preamble."
+          },
           { role: "user", content: prompt }
         ],
         max_tokens: 128
       });
-      const res = await fetch(`${CLOUD_API_URL}/api/proxy/chat`, {
-        method: "POST",
-        headers,
-        body: reqBody
-      });
-      const resText = await res.text();
-      const duration3 = Math.round(performance.now() - start);
-      logRequest?.("POST", "/api/proxy/chat", res.status, duration3, "cloud", reqBody, resText);
-      if (!res.ok) {
-        throw new Error(`Cloud purpose failed (${res.status}): ${resText}`);
-      }
+      const { res, resText } = await cloudFetch("/api/proxy/chat", reqBody);
+      if (!res.ok) throw new Error(`Cloud purpose failed (${res.status}): ${resText}`);
       const data = JSON.parse(resText);
       trackUsage?.("purpose_requests");
       return data.choices?.[0]?.message?.content?.trim() ?? "";
@@ -15655,7 +16690,7 @@ function flattenError(error3, mapper = (issue2) => issue2.message) {
   }
   return { formErrors, fieldErrors };
 }
-function formatError(error3, _mapper) {
+function formatError2(error3, _mapper) {
   const mapper = _mapper || function(issue2) {
     return issue2.message;
   };
@@ -19301,7 +20336,7 @@ var init_errors4 = __esm({
       inst.name = "ZodError";
       Object.defineProperties(inst, {
         format: {
-          value: (mapper) => formatError(inst, mapper)
+          value: (mapper) => formatError2(inst, mapper)
           // enumerable: false,
         },
         flatten: {
@@ -32382,7 +33417,17 @@ __export(mcp_exports, {
 });
 import { randomUUID as randomUUID3 } from "crypto";
 function logMcp(method, path, status, duration3, reqBody, resSize, resBody, trace) {
-  getRawDb().prepare(LOG_SQL).run(randomUUID3(), method, path, status, duration3, reqBody ?? null, resSize ?? null, resBody ?? null, trace ?? null);
+  getRawDb().prepare(LOG_SQL).run(
+    randomUUID3(),
+    method,
+    path,
+    status,
+    duration3,
+    reqBody ?? null,
+    resSize ?? null,
+    resBody ?? null,
+    trace ?? null
+  );
 }
 function text2(s) {
   return { content: [{ type: "text", text: s }] };
@@ -32401,7 +33446,7 @@ function createMcpServer(db, caps) {
   server.registerTool(
     "get_context",
     {
-      description: "Prefer this tool over Grep/Glob when searching for files relevant to a task across the codebase. Returns ranked files, imports, and co-change clusters for a development goal. Skip for simple lookups where you already know the file path or location.",
+      description: "Returns ranked files with import dependency chains and git co-change clusters for a development goal. Surfaces structural relationships (imports, co-changes, exports) that keyword search alone won't find. Use when exploring architecture, tracing data flow, assessing change impact, or navigating an unfamiliar codebase. Skip for simple lookups where you already know the file path.",
       inputSchema: { repo_path: external_exports.string(), goal: external_exports.string() }
     },
     async ({ repo_path, goal }) => {
@@ -32416,11 +33461,29 @@ function createMcpServer(db, caps) {
         const result = await buildContext(db, repoId, goal, caps, trace, { useEmbeddings });
         const duration3 = Math.round(performance.now() - start);
         const reqBody = JSON.stringify({ repo_path, goal });
-        logMcp("MCP", "/tool/get_context", 200, duration3, reqBody, result.context_pack.length, result.context_pack, trace.serialize());
+        logMcp(
+          "MCP",
+          "/tool/get_context",
+          200,
+          duration3,
+          reqBody,
+          result.context_pack.length,
+          result.context_pack,
+          trace.serialize()
+        );
         return text2(result.context_pack);
       } catch (e) {
         const duration3 = Math.round(performance.now() - start);
-        logMcp("MCP", "/tool/get_context", 500, duration3, JSON.stringify({ repo_path, goal }), void 0, e.message, trace.serialize());
+        logMcp(
+          "MCP",
+          "/tool/get_context",
+          500,
+          duration3,
+          JSON.stringify({ repo_path, goal }),
+          void 0,
+          e.message,
+          trace.serialize()
+        );
         return error2(e.message);
       }
     }
@@ -32458,7 +33521,7 @@ function createMcpServer(db, caps) {
         const repo = repoQueries.getByPath(db, repo_path);
         if (!repo) {
           logMcp("MCP", "/tool/get_status", 404, Math.round(performance.now() - start), JSON.stringify({ repo_path }));
-          return error2("repo not found at " + repo_path);
+          return error2(`repo not found at ${repo_path}`);
         }
         const status = await getRepoStatus(db, repo.id);
         const body = JSON.stringify(status, null, 2);
@@ -32488,11 +33551,29 @@ function createMcpServer(db, caps) {
         const result = await runIndex(db, repoId, caps, force ?? false, void 0, trace);
         const body = JSON.stringify(result, null, 2);
         const duration3 = Math.round(performance.now() - start);
-        logMcp("MCP", "/tool/index_repo", 200, duration3, JSON.stringify({ repo_path, force }), body.length, body, trace.serialize());
+        logMcp(
+          "MCP",
+          "/tool/index_repo",
+          200,
+          duration3,
+          JSON.stringify({ repo_path, force }),
+          body.length,
+          body,
+          trace.serialize()
+        );
         return text2(body);
       } catch (e) {
         const duration3 = Math.round(performance.now() - start);
-        logMcp("MCP", "/tool/index_repo", 500, duration3, JSON.stringify({ repo_path, force }), void 0, e.message, trace.serialize());
+        logMcp(
+          "MCP",
+          "/tool/index_repo",
+          500,
+          duration3,
+          JSON.stringify({ repo_path, force }),
+          void 0,
+          e.message,
+          trace.serialize()
+        );
         return error2(e.message);
       }
     }
@@ -34816,9 +35897,9 @@ var server_exports = {};
 __export(server_exports, {
   createApp: () => createApp
 });
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, statSync, watch as watch2 } from "fs";
-import { join as join5, extname as extname3 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync, watch as watch2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
+import { extname as extname3, join as join5 } from "path";
 function getDbSizeMb() {
   const dbPath = join5(homedir3(), ".lens", "data.db");
   try {
@@ -34849,7 +35930,7 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
   const app = new Hono2();
   const telemetryEnabled = isTelemetryEnabled();
   setTelemetryEnabled(telemetryEnabled);
-  const { telemetry_id, first_run } = ensureTelemetryId();
+  const { first_run } = ensureTelemetryId();
   if (first_run) {
     console.log(
       "[LENS] Anonymous telemetry is enabled. No PII, no repo paths, no code.\n[LENS] Opt out: lens config set telemetry false"
@@ -34925,18 +36006,6 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
       const trace = c.get("trace");
       const { root_path, name, remote_url } = await c.req.json();
       if (!root_path) return c.json({ error: "root_path required" }, 400);
-      trace.step("quotaCheck");
-      const currentRepos = listRepos(db).length;
-      const maxRepos = quotaCache?.quota?.maxRepos ?? 50;
-      trace.end("quotaCheck", `${currentRepos}/${maxRepos}`);
-      if (currentRepos >= maxRepos) {
-        return c.json({
-          error: "Repo limit reached",
-          current: currentRepos,
-          limit: maxRepos,
-          plan: quotaCache?.plan ?? "unknown"
-        }, 429);
-      }
       trace.step("registerRepo");
       const result = registerRepo(db, root_path, name, remote_url);
       trace.end("registerRepo", result.created ? "created" : "existing");
@@ -34952,37 +36021,64 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
           const tasks = [];
           if (repo?.enable_vocab_clusters && quotaRemaining("embeddingChunks") > 0) {
             bg.step("vocabClusters");
-            tasks.push(buildVocabClusters(db, result.repo_id, caps).then(() => {
-              bg.end("vocabClusters");
-              results.vocabClusters = "done";
-            }));
+            tasks.push(
+              buildVocabClusters(db, result.repo_id, caps).then(() => {
+                bg.end("vocabClusters");
+                results.vocabClusters = "done";
+              })
+            );
           } else {
             bg.add("vocabClusters", 0, !repo?.enable_vocab_clusters ? "disabled" : "quota exceeded");
           }
           if (repo?.enable_embeddings && quotaRemaining("embeddingChunks") > 0) {
             bg.step("embeddings");
-            tasks.push(ensureEmbedded(db, result.repo_id, caps).then((er) => {
-              bg.end("embeddings", `${er.embedded_count} embedded`);
-              results.embeddings = er;
-            }));
+            tasks.push(
+              ensureEmbedded(db, result.repo_id, caps).then((er) => {
+                bg.end("embeddings", `${er.embedded_count} embedded`);
+                results.embeddings = er;
+              })
+            );
           } else {
             bg.add("embeddings", 0, !repo?.enable_embeddings ? "disabled" : "quota exceeded");
           }
           if (repo?.enable_summaries && quotaRemaining("purposeRequests") > 0) {
             bg.step("purpose");
-            tasks.push(enrichPurpose(db, result.repo_id, caps).then((pr) => {
-              bg.end("purpose", `${pr.enriched} enriched`);
-              results.purpose = pr;
-            }));
+            tasks.push(
+              enrichPurpose(db, result.repo_id, caps).then((pr) => {
+                bg.end("purpose", `${pr.enriched} enriched`);
+                results.purpose = pr;
+              })
+            );
           } else {
             bg.add("purpose", 0, !repo?.enable_summaries ? "disabled" : "quota exceeded");
           }
           await Promise.all(tasks);
           const resBody = JSON.stringify(results);
           const bgDuration = Math.round(performance.now() - bgStart);
-          logQueries.insert(db, "BG", `/enrichment/${result.repo_id}`, 200, bgDuration, "system", reqBody, resBody.length, resBody, bg.serialize());
+          logQueries.insert(
+            db,
+            "BG",
+            `/enrichment/${result.repo_id}`,
+            200,
+            bgDuration,
+            "system",
+            reqBody,
+            resBody.length,
+            resBody,
+            bg.serialize()
+          );
         }).catch((e) => {
-          logQueries.insert(db, "BG", `/enrichment/${result.repo_id}`, 500, 0, "system", JSON.stringify({ repo_id: result.repo_id }), void 0, String(e));
+          logQueries.insert(
+            db,
+            "BG",
+            `/enrichment/${result.repo_id}`,
+            500,
+            0,
+            "system",
+            JSON.stringify({ repo_id: result.repo_id }),
+            void 0,
+            String(e)
+          );
         });
       }
       trace.step("startWatcher");
@@ -35099,6 +36195,20 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
       return c.json({ error: e.message }, 500);
     }
   });
+  trackRoute("POST", "/eval/run");
+  app.post("/eval/run", async (c) => {
+    try {
+      const trace = c.get("trace");
+      const { repo_id, filter_kind } = await c.req.json();
+      if (!repo_id) return c.json({ error: "repo_id required" }, 400);
+      trace.step("runEval");
+      const summary = await runEval(db, repo_id, { filterKind: filter_kind });
+      trace.end("runEval", `${summary.total} queries`);
+      return c.json(summary);
+    } catch (e) {
+      return c.json({ error: e.message }, 500);
+    }
+  });
   trackRoute("POST", "/index/run");
   app.post("/index/run", async (c) => {
     try {
@@ -35114,35 +36224,52 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
       const tasks = [];
       if (repo?.enable_vocab_clusters && quotaRemaining("embeddingChunks") > 0) {
         bg.step("vocabClusters");
-        tasks.push(buildVocabClusters(db, repo_id, caps).then(() => {
-          bg.end("vocabClusters");
-          results.vocabClusters = "done";
-        }));
+        tasks.push(
+          buildVocabClusters(db, repo_id, caps).then(() => {
+            bg.end("vocabClusters");
+            results.vocabClusters = "done";
+          })
+        );
       } else {
         bg.add("vocabClusters", 0, !repo?.enable_vocab_clusters ? "disabled" : "quota exceeded");
       }
       if (repo?.enable_embeddings && quotaRemaining("embeddingChunks") > 0) {
         bg.step("embeddings");
-        tasks.push(ensureEmbedded(db, repo_id, caps).then((er) => {
-          bg.end("embeddings", `${er.embedded_count} embedded`);
-          results.embeddings = er;
-        }));
+        tasks.push(
+          ensureEmbedded(db, repo_id, caps).then((er) => {
+            bg.end("embeddings", `${er.embedded_count} embedded`);
+            results.embeddings = er;
+          })
+        );
       } else {
         bg.add("embeddings", 0, !repo?.enable_embeddings ? "disabled" : "quota exceeded");
       }
       if (repo?.enable_summaries && quotaRemaining("purposeRequests") > 0) {
         bg.step("purpose");
-        tasks.push(enrichPurpose(db, repo_id, caps).then((pr) => {
-          bg.end("purpose", `${pr.enriched} enriched`);
-          results.purpose = pr;
-        }));
+        tasks.push(
+          enrichPurpose(db, repo_id, caps).then((pr) => {
+            bg.end("purpose", `${pr.enriched} enriched`);
+            results.purpose = pr;
+          })
+        );
       } else {
         bg.add("purpose", 0, !repo?.enable_summaries ? "disabled" : "quota exceeded");
       }
       Promise.all(tasks).then(() => {
         const resBody = JSON.stringify(results);
         const bgDuration = Math.round(performance.now() - bgStart);
-        logQueries.insert(db, "BG", `/enrichment/${repo_id}`, 200, bgDuration, "system", reqBody, resBody.length, resBody, bg.serialize());
+        logQueries.insert(
+          db,
+          "BG",
+          `/enrichment/${repo_id}`,
+          200,
+          bgDuration,
+          "system",
+          reqBody,
+          resBody.length,
+          resBody,
+          bg.serialize()
+        );
       }).catch((e) => {
         logQueries.insert(db, "BG", `/enrichment/${repo_id}`, 500, 0, "system", reqBody, void 0, String(e));
       });
@@ -35288,24 +36415,34 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
       expires_at: Math.floor(Date.now() / 1e3) + (data.expires_in ?? 3600)
     };
   }
-  const repoClients = /* @__PURE__ */ new Set();
+  const sseClients = /* @__PURE__ */ new Set();
   const encoder = new TextEncoder();
-  function emitRepoEvent() {
-    for (const ctrl of repoClients) {
+  function emitSSE(type) {
+    const payload = encoder.encode(`data: ${JSON.stringify({ type })}
+
+`);
+    for (const ctrl of sseClients) {
       try {
-        ctrl.enqueue(encoder.encode("data: repo-changed\n\n"));
+        ctrl.enqueue(payload);
       } catch {
-        repoClients.delete(ctrl);
+        sseClients.delete(ctrl);
       }
     }
   }
-  trackRoute("GET", "/api/repo/events");
-  app.get("/api/repo/events", (c) => {
+  function emitRepoEvent() {
+    emitSSE("repo");
+  }
+  function emitAuthEvent() {
+    emitSSE("auth");
+  }
+  trackRoute("GET", "/api/events");
+  app.get("/api/events", (_c) => {
     const stream = new ReadableStream({
       start(ctrl) {
-        repoClients.add(ctrl);
+        sseClients.add(ctrl);
       },
-      cancel() {
+      cancel(ctrl) {
+        sseClients.delete(ctrl);
       }
     });
     return new Response(stream, {
@@ -35316,17 +36453,7 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
       }
     });
   });
-  const authClients = /* @__PURE__ */ new Set();
   const authDir = join5(homedir3(), ".lens");
-  function emitAuthEvent() {
-    for (const ctrl of authClients) {
-      try {
-        ctrl.enqueue(encoder.encode("data: auth-changed\n\n"));
-      } catch {
-        authClients.delete(ctrl);
-      }
-    }
-  }
   try {
     watch2(authDir, (_, filename) => {
       if (filename && filename !== "auth.json") return;
@@ -35334,23 +36461,6 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
     });
   } catch {
   }
-  trackRoute("GET", "/api/auth/events");
-  app.get("/api/auth/events", (c) => {
-    const stream = new ReadableStream({
-      start(ctrl) {
-        authClients.add(ctrl);
-      },
-      cancel() {
-      }
-    });
-    return new Response(stream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      }
-    });
-  });
   trackRoute("POST", "/api/auth/notify");
   app.post("/api/auth/notify", async (c) => {
     await refreshQuotaCache();
@@ -35602,7 +36712,9 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
       const search = c.req.query("search") || void 0;
       const meta = metadataQueries.getByRepo(db, id);
       const raw2 = getRawDb();
-      const chunkCounts = raw2.prepare("SELECT path, count(*) as chunk_count, SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) as embedded_count FROM chunks WHERE repo_id = ? GROUP BY path").all(id);
+      const chunkCounts = raw2.prepare(
+        "SELECT path, count(*) as chunk_count, SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) as embedded_count FROM chunks WHERE repo_id = ? GROUP BY path"
+      ).all(id);
       const countMap = new Map(chunkCounts.map((r) => [r.path, r]));
       let all = meta.map((m) => {
         const counts = countMap.get(m.path);
@@ -35637,12 +36749,16 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
       const meta = allMeta.find((m) => m.path === filePath);
       if (!meta) return c.json({ error: "file not found" }, 404);
       const raw2 = getRawDb();
-      const chunkRow = raw2.prepare("SELECT count(*) as chunk_count, SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) as embedded_count FROM chunks WHERE repo_id = ? AND path = ?").get(id, filePath);
+      const chunkRow = raw2.prepare(
+        "SELECT count(*) as chunk_count, SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) as embedded_count FROM chunks WHERE repo_id = ? AND path = ?"
+      ).get(id, filePath);
       const allImports = importQueries.getBySources(db, id, [filePath]);
       const allImporters = importQueries.getByTargets(db, id, [filePath]);
       const gitStats = statsQueries.getByRepo(db, id);
       const fileStat = gitStats.get(filePath);
-      const cochangeRows = raw2.prepare("SELECT path_a, path_b, cochange_count FROM file_cochanges WHERE repo_id = ? AND (path_a = ? OR path_b = ?) ORDER BY cochange_count DESC LIMIT 10").all(id, filePath, filePath);
+      const cochangeRows = raw2.prepare(
+        "SELECT path_a, path_b, cochange_count FROM file_cochanges WHERE repo_id = ? AND (path_a = ? OR path_b = ?) ORDER BY cochange_count DESC LIMIT 10"
+      ).all(id, filePath, filePath);
       const cochanges = cochangeRows.map((r) => ({
         path: r.path_a === filePath ? r.path_b : r.path_a,
         count: r.cochange_count
@@ -35682,7 +36798,9 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
       const raw2 = getRawDb();
       const where = pathFilter ? "WHERE repo_id = ? AND path = ?" : "WHERE repo_id = ?";
       const params = pathFilter ? [id, pathFilter] : [id];
-      const rows = raw2.prepare(`SELECT id, path, chunk_index, start_line, end_line, language, CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END as has_embedding FROM chunks ${where} ORDER BY path, chunk_index LIMIT ? OFFSET ?`).all(...params, limit, offset);
+      const rows = raw2.prepare(
+        `SELECT id, path, chunk_index, start_line, end_line, language, CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END as has_embedding FROM chunks ${where} ORDER BY path, chunk_index LIMIT ? OFFSET ?`
+      ).all(...params, limit, offset);
       const totalRow = raw2.prepare(`SELECT count(*) as count FROM chunks ${where}`).get(...params);
       return c.json({
         chunks: rows.map((r) => ({ ...r, has_embedding: r.has_embedding === 1 })),
@@ -35698,7 +36816,9 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
       const id = c.req.param("id");
       const chunkId = c.req.param("chunkId");
       const raw2 = getRawDb();
-      const row = raw2.prepare("SELECT id, path, chunk_index, start_line, end_line, content, language, chunk_hash, CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END as has_embedding FROM chunks WHERE id = ? AND repo_id = ?").get(chunkId, id);
+      const row = raw2.prepare(
+        "SELECT id, path, chunk_index, start_line, end_line, content, language, chunk_hash, CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END as has_embedding FROM chunks WHERE id = ? AND repo_id = ?"
+      ).get(chunkId, id);
       if (!row) return c.json({ error: "chunk not found" }, 404);
       return c.json({ ...row, has_embedding: row.has_embedding === 1 });
     } catch (e) {
@@ -35739,7 +36859,9 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
   app.get("/api/dashboard/tables", (c) => {
     try {
       const raw2 = getRawDb();
-      const tables = raw2.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle%' ORDER BY name").all();
+      const tables = raw2.prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle%' ORDER BY name"
+      ).all();
       const result = tables.map((t) => {
         const row = raw2.prepare(`SELECT count(*) as count FROM "${t.name}"`).get();
         return { name: t.name, count: row.count };
@@ -35875,7 +36997,8 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
           if (apiKey) {
             const { createCloudCapabilities: createCloudCapabilities2 } = await Promise.resolve().then(() => (init_cloud_capabilities(), cloud_capabilities_exports));
             caps = createCloudCapabilities2(
-              apiKey,
+              () => readApiKey(),
+              provisionApiKey,
               (counter, amount) => {
                 try {
                   usageQueries.increment(db, counter, amount);
@@ -35905,7 +37028,7 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
         caps = void 0;
       }
     } catch {
-      quotaCache = { plan: "free", usage: {}, quota: {}, fetchedAt: Date.now() };
+      quotaCache = { plan: "free", usage: {}, quota: {}, subscription: null, fetchedAt: Date.now() };
       caps = void 0;
     }
   }
@@ -35934,7 +37057,10 @@ function createApp(db, dashboardDist, initialCaps, initialPlanData) {
         signal: AbortSignal.timeout(1e4)
       });
       if (res.ok) {
-        telemetryQueries.markSynced(db, unsynced.map((e) => e.id));
+        telemetryQueries.markSynced(
+          db,
+          unsynced.map((e) => e.id)
+        );
       }
     } catch {
     }
@@ -35953,16 +37079,15 @@ var TEMPLATE, startedAt, MIME_TYPES, QUOTA_TTL, quotaCache;
 var init_server3 = __esm({
   "apps/daemon/src/server.ts"() {
     "use strict";
+    init_dist();
     init_dist2();
     init_config();
-    init_dist();
     TEMPLATE = `<!-- LENS \u2014 Repo Context Daemon -->
 ## LENS Context
 
-This repo is indexed by LENS. Use the MCP context tool or run:
-\`\`\`
-lens context "<your goal>"
-\`\`\``;
+This repo is indexed by LENS. When exploring architecture, tracing data flow, or assessing change impact, call \`mcp__lens__get_context\` \u2014 it returns ranked files with import chains and co-change clusters that keyword search alone won't surface.
+
+CLI alternative: \`lens context "<your goal>"\``;
     startedAt = Date.now();
     MIME_TYPES = {
       ".html": "text/html",
@@ -36548,13 +37673,14 @@ var init_dist3 = __esm({
 // apps/daemon/src/index.ts
 init_dist();
 init_config();
-import { writeFileSync as writeFileSync3, unlinkSync, readFileSync as readFileSync3, statSync as statSync2, watchFile as watchFile2, openSync } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir4 } from "os";
 import { spawn } from "child_process";
+import { openSync, readFileSync as readFileSync3, statSync as statSync2, unlinkSync, watchFile as watchFile2, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
 var LENS_DIR = join6(homedir4(), ".lens");
 var PID_FILE = join6(LENS_DIR, "daemon.pid");
 var LOG_FILE = join6(LENS_DIR, "daemon.log");
+var AUTH_FILE = join6(LENS_DIR, "auth.json");
 function writePid() {
   writeFileSync3(PID_FILE, String(process.pid));
 }
@@ -36564,76 +37690,97 @@ function removePid() {
   } catch {
   }
 }
-async function ensureApiKey(data) {
-  if (data.api_key) return data.api_key;
-  if (!data.access_token) return void 0;
-  const cloudUrl = getCloudUrl();
+function readApiKeyFromDisk() {
+  try {
+    const data = JSON.parse(readFileSync3(AUTH_FILE, "utf-8"));
+    return data.api_key || null;
+  } catch {
+    return null;
+  }
+}
+async function provisionNewKey() {
   try {
+    const data = JSON.parse(readFileSync3(AUTH_FILE, "utf-8"));
+    if (!data.access_token) return null;
+    const cloudUrl = getCloudUrl();
     const res = await fetch(`${cloudUrl}/auth/key`, {
       headers: { Authorization: `Bearer ${data.access_token}` }
     });
-    if (!res.ok) {
-      console.error(`[LENS] API key provisioning failed (${res.status})`);
-      return void 0;
-    }
+    if (!res.ok) return null;
     const { api_key } = await res.json();
     data.api_key = api_key;
-    const authPath = join6(homedir4(), ".lens", "auth.json");
-    writeFileSync3(authPath, JSON.stringify(data, null, 2), { mode: 384 });
-    console.error("[LENS] API key auto-provisioned");
+    writeFileSync3(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+    console.error("[LENS] API key re-provisioned");
     return api_key;
-  } catch (e) {
-    console.error(`[LENS] API key provisioning error: ${e?.message}`);
-    return void 0;
+  } catch {
+    return null;
   }
 }
 async function loadCapabilities(db) {
   try {
-    const authPath = join6(homedir4(), ".lens", "auth.json");
-    const data = JSON.parse(readFileSync3(authPath, "utf-8"));
-    const apiKey = await ensureApiKey(data);
-    if (!apiKey) return {};
+    let apiKey = readApiKeyFromDisk();
+    if (!apiKey) {
+      apiKey = await provisionNewKey();
+      if (!apiKey) return {};
+    }
     const cloudUrl = getCloudUrl();
     const res = await fetch(`${cloudUrl}/api/usage/current`, {
       headers: { Authorization: `Bearer ${apiKey}` }
     });
+    if (res.status === 401) {
+      apiKey = await provisionNewKey();
+      if (!apiKey) return {};
+      const retry = await fetch(`${cloudUrl}/api/usage/current`, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!retry.ok) {
+        console.error(`[LENS] Plan check failed after re-provision (${retry.status})`);
+        return {};
+      }
+      const usageData2 = await retry.json();
+      return buildCapsResult(db, usageData2);
+    }
     if (!res.ok) {
       console.error(`[LENS] Plan check failed (${res.status}), capabilities disabled`);
       return {};
     }
     const usageData = await res.json();
-    const planData = {
-      plan: usageData.plan ?? "free",
-      usage: usageData.usage ?? {},
-      quota: usageData.quota ?? {}
-    };
-    if (usageData.plan !== "pro") {
-      console.error(`[LENS] Plan: ${usageData.plan ?? "free"} \u2014 Pro features disabled`);
-      return { planData };
-    }
-    const { createCloudCapabilities: createCloudCapabilities2 } = await Promise.resolve().then(() => (init_cloud_capabilities(), cloud_capabilities_exports));
-    const { usageQueries: usageQueries2, logQueries: logQueries2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
-    const caps = createCloudCapabilities2(
-      apiKey,
-      (counter, amount) => {
-        try {
-          usageQueries2.increment(db, counter, amount);
-        } catch {
-        }
-      },
-      (method, path, status, duration3, source, reqBody, resBody) => {
-        try {
-          logQueries2.insert(db, method, path, status, duration3, source, reqBody, resBody?.length, resBody);
-        } catch {
-        }
-      }
-    );
-    console.error("[LENS] Cloud capabilities enabled (Pro plan)");
-    return { caps, planData };
+    return buildCapsResult(db, usageData);
   } catch {
     return {};
   }
 }
+async function buildCapsResult(db, usageData) {
+  const planData = {
+    plan: usageData.plan ?? "free",
+    usage: usageData.usage ?? {},
+    quota: usageData.quota ?? {}
+  };
+  if (usageData.plan !== "pro") {
+    console.error(`[LENS] Plan: ${usageData.plan ?? "free"} \u2014 Pro features disabled`);
+    return { planData };
+  }
+  const { createCloudCapabilities: createCloudCapabilities2 } = await Promise.resolve().then(() => (init_cloud_capabilities(), cloud_capabilities_exports));
+  const { usageQueries: usageQueries2, logQueries: logQueries2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const caps = createCloudCapabilities2(
+    () => Promise.resolve(readApiKeyFromDisk()),
+    provisionNewKey,
+    (counter, amount) => {
+      try {
+        usageQueries2.increment(db, counter, amount);
+      } catch {
+      }
+    },
+    (method, path, status, duration3, source, reqBody, resBody) => {
+      try {
+        logQueries2.insert(db, method, path, status, duration3, source, reqBody, resBody?.length, resBody);
+      } catch {
+      }
+    }
+  );
+  console.error("[LENS] Cloud capabilities enabled (Pro plan)");
+  return { caps, planData };
+}
 async function main() {
   const db = openDb();
   const { caps, planData } = await loadCapabilities(db);
@@ -36665,11 +37812,11 @@ async function main() {
     var shutdown = shutdown2;
     const { createApp: createApp2 } = await Promise.resolve().then(() => (init_server3(), server_exports));
     const { serve: serve2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
-    const { resolve: resolve4, dirname: dirname5 } = await import("path");
+    const { resolve: resolve4, dirname: dirname4 } = await import("path");
     const { existsSync: existsSync3 } = await import("fs");
     const { fileURLToPath } = await import("url");
     const port = Number(process.env.LENS_PORT) || 4111;
-    const selfDir = dirname5(fileURLToPath(import.meta.url));
+    const selfDir = dirname4(fileURLToPath(import.meta.url));
     const candidates = [
       resolve4(selfDir, "../../dashboard/dist"),
       // monorepo dev