lens-engine 0.1.20 → 0.1.21

package/daemon.js

@@ -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,
+  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,
@@ -7704,6 +7710,49 @@ function fromEmbeddingBlob(blob2) {
   const buf = blob2 instanceof Buffer ? blob2 : Buffer.from(blob2);
   return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
 }
+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 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
+    });
+  }
+  return result;
+}
 function setTelemetryEnabled(enabled) {
   _enabled = enabled;
 }
@@ -8445,101 +8494,372 @@ async function ensureIndexed(db, repoId, caps) {
   if (repo.last_indexed_commit === head) return null;
   return runIndex(db, repoId, caps);
 }
+function estimateTokens(s) {
+  return Math.ceil(s.length / 4);
+}
 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 guessLang(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot < 0) return "";
+  return LANG_EXT[path.substring(dot + 1)] ?? "";
 }
-function formatContextPack(data) {
-  const L = [];
-  const files = data.files.slice(0, 15);
-  const exportsMap = /* @__PURE__ */ new Map();
+function getPurpose(path, data) {
   for (const m of data.metadata) {
-    if (m.exports?.length) exportsMap.set(m.path, m.exports);
+    if (m.path === path && m.purpose) return m.purpose;
   }
+  return "";
+}
+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 });
+  }
+  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 [];
+}
+function fileLabel(path, snippet) {
+  const line = snippet?.line ? `:${snippet.line}` : "";
+  return `${path}${line}`;
+}
+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("");
-  if (files.length > 0) {
-    L.push("## Files");
-    for (let i = 0; i < files.length; i++) {
+  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 exports = exportsMap.get(f.path);
-      const exportStr = exports?.length ? ` \u2014 exports: ${exports.slice(0, 5).join(", ")}` : "";
-      L.push(`${i + 1}. ${f.path}${exportStr}`);
+      const p = getPurpose(f.path, data);
+      L.push(`${i + 1}. ${f.path}${p ? ` \u2014 ${p}` : ""}`);
     }
+  }
+  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}` : ""}`);
+    }
   }
-  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(", ")}`);
+  return L.join("\n");
+}
+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);
+  }
+  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 stripCodeSlices(lines) {
+  const result = [];
+  let inFence = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```") && !inFence) {
+      inFence = true;
+      continue;
     }
-    if (rev?.length) {
-      let revStr = rev.slice(0, 4).map(basename3).join(", ");
-      if (hop2?.length) {
-        revStr += ` \u2192 ${hop2.slice(0, 3).map(basename3).join(", ")}`;
+    if (inFence && line.trimStart().startsWith("```")) {
+      inFence = false;
+      continue;
+    }
+    if (!inFence) result.push(line);
+  }
+  return result;
+}
+function progressiveStrip(output, _data) {
+  let lines = output.split("\n");
+  if (estimateTokens(lines.join("\n")) > TOKEN_CAP) {
+    lines = stripCodeSlices(lines);
+  }
+  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()}`;
       }
-      depLines.push(`  imported by: ${revStr}`);
+      return l;
+    });
+  }
+  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);
     }
   }
-  if (depLines.length > 0) {
-    L.push("## Dependency Graph");
-    for (const line of depLines) L.push(line);
-    L.push("");
+  if (estimateTokens(lines.join("\n")) > TOKEN_CAP) {
+    lines = lines.filter((l) => {
+      const trimmed = l.trimStart();
+      return !(trimmed.startsWith("\u2190") || trimmed.startsWith("\u2192")) || !trimmed.includes("|");
+    });
   }
-  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`);
+  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;
       }
-      L.push("");
+      reduced.push(line);
     }
+    lines = reduced;
   }
-  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 (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;
+    });
+  }
+  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;
   }
-  if (activityLines.length > 0) {
-    L.push("## Activity");
-    for (const line of activityLines) L.push(line);
+  if (estimateTokens(output) > TOKEN_CAP) {
+    output = progressiveStrip(output, filtered);
   }
-  return L.join("\n");
+  return output;
 }
-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;
+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 });
       }
     }
-    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 frames;
+}
+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 };
+  }
+  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 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 };
+  }
+  return { kind: "natural", raw: query, frames, symbol: null, errorToken: null, naturalTokens };
 }
 function stem(word) {
   if (word.length <= 4) return word;
@@ -8547,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) {
@@ -8555,7 +8876,7 @@ function expandKeywords(words, clusters) {
     if (s.length >= 3 && s !== w) stemmed.add(s);
     if (w.includes("-")) {
       for (const part of w.split("-")) {
-        if (part.length > 2 && !STOPWORDS.has(part)) {
+        if (part.length > 2 && !STOPWORDS2.has(part)) {
           exact.add(part);
           const ps = stem(part);
           if (ps.length >= 3 && ps !== part) stemmed.add(ps);
@@ -8566,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();
@@ -8604,17 +8930,17 @@ function buildTermWeights(words, metadata) {
   }
   return weights;
 }
-function interpretQuery(query, metadata, fileStats2, vocabClusters, indegrees, maxImportDepth) {
-  const rawWords = query.toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS.has(w));
-  const { exact, stemmed, clusterFiles } = expandKeywords(rawWords, vocabClusters ?? null);
-  const allTerms = [...exact, ...stemmed];
+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, 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) {
     const tokens = /* @__PURE__ */ new Set();
     for (const exp of f.exports ?? []) {
       for (const part of exp.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s_-]+/)) {
-        if (part.length >= 3 && !STOPWORDS.has(part)) tokens.add(part);
+        if (part.length >= 3 && !STOPWORDS2.has(part)) tokens.add(part);
       }
     }
     exportTokensMap.set(f.path, tokens);
@@ -8634,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;
@@ -8647,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;
@@ -8662,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) {
@@ -8696,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) : "";
@@ -8712,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);
 }
@@ -8774,6 +9242,37 @@ 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;
@@ -8834,18 +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);
@@ -8861,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) {
@@ -8945,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,
@@ -8954,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");
@@ -8967,7 +9521,18 @@ async function buildContext(db, repoId, goal, caps, trace, options) {
         cached: false
       }
     };
-    cacheSet(key, 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,
@@ -9166,7 +9731,102 @@ function createTablesSql() {
     CREATE INDEX IF NOT EXISTS idx_telemetry_events_synced ON telemetry_events(synced_at);
   `;
 }
-function estimateTokens(text22) {
+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) {
@@ -9192,7 +9852,7 @@ async function ensureEmbedded(db, repoId, caps) {
       const batch = [];
       let batchTokens = 0;
       while (offset < validRows.length) {
-        const est = estimateTokens(validRows[offset].content);
+        const est = estimateTokens2(validRows[offset].content);
         if (batch.length > 0 && batchTokens + est > MAX_BATCH_TOKENS) break;
         batch.push(validRows[offset]);
         batchTokens += est;
@@ -9255,7 +9915,7 @@ async function enrichPurpose(db, repoId, caps, fullRun = false) {
   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 && !STOPWORDS2.has(w));
+  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();
@@ -9596,7 +10256,7 @@ async function getRepoStatus(db, id) {
     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, _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, STOPWORDS, NOISE_EXTENSIONS, NOISE_PATHS, CONCEPT_SYNONYMS, CACHE_TTL, CACHE_MAX, cache, _db, _raw, 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, STOPWORDS2, watchers, debounceTimers, IGNORED, DEBOUNCE_MS, 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";
@@ -9982,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(*)`,
@@ -10328,6 +11003,23 @@ var init_dist = __esm({
         };
       }
     });
+    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();
@@ -10476,6 +11168,40 @@ var init_dist = __esm({
     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",
@@ -10577,6 +11303,139 @@ var init_dist = __esm({
       "mock",
       "module"
     ]);
+    STOPWORDS2 = /* @__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",
+      "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",
+      "export",
+      "default",
+      "class",
+      "function",
+      "string",
+      "number",
+      "boolean",
+      "object",
+      "array",
+      "index",
+      "data",
+      "value",
+      "result",
+      "item",
+      "list",
+      "name",
+      "id",
+      "key",
+      "src",
+      "lib",
+      "app",
+      "spec",
+      "mock",
+      "module",
+      "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",
@@ -10611,6 +11470,7 @@ var init_dist = __esm({
       "node_modules/",
       "dist/",
       "build/",
+      "publish/",
       "vendor/",
       "vendors/",
       "/scripts/",
@@ -10649,6 +11509,9 @@ var init_dist = __esm({
       api: ["controller", "endpoint", "route", "middleware", "interceptor"]
     };
     init_queries();
+    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;
@@ -10657,6 +11520,159 @@ var init_dist = __esm({
     _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"
+      }
+    ];
     init_queries();
     MAX_API_CALLS = 2e3;
     POOL_SIZE = 32;
@@ -10671,7 +11687,7 @@ var init_dist = __esm({
     MAX_TERMS = 1500;
     MAX_CLUSTERS = 200;
     MAX_CLUSTER_SIZE = 12;
-    STOPWORDS2 = /* @__PURE__ */ new Set([
+    STOPWORDS3 = /* @__PURE__ */ new Set([
       "the",
       "a",
       "an",
@@ -10888,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);
@@ -10926,7 +11956,6 @@ function createCloudCapabilities(apiKey, trackUsage, logRequest) {
         "",
         content.slice(0, 2e3)
       ].filter(Boolean).join("\n");
-      const start = performance.now();
       const reqBody = JSON.stringify({
         messages: [
           {
@@ -10937,17 +11966,8 @@ function createCloudCapabilities(apiKey, trackUsage, logRequest) {
         ],
         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() ?? "";
@@ -15670,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;
   };
@@ -19316,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: {
@@ -32426,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 }) => {
@@ -34986,21 +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");
@@ -35190,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 {
@@ -35396,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, {
@@ -35424,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;
@@ -35442,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();
@@ -35995,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);
@@ -36082,10 +37085,9 @@ var init_server3 = __esm({
     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",
@@ -36678,6 +37680,7 @@ 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));
 }
@@ -36687,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);