orion-super-agent-dev 0.1.28 → 0.1.30

package/out/indexProcessWorker.cjs

@@ -1442,6 +1442,8 @@ ${JSON.stringify(t2, null, 2)}`);
 });
 
 // ../packages/orion-client-core/src/indexProcessWorker.ts
+var import_fs4 = require("fs");
+var path6 = __toESM(require("path"));
 var v8 = __toESM(require("v8"));
 
 // ../packages/orion-client-core/src/nodeFileSource.ts
@@ -1725,26 +1727,26 @@ function tokenizeSearchText(text) {
 function tokenizeContentText(text) {
   return [...iterateTokens(text)];
 }
-function pathSegments(path5) {
-  return path5.replace(/\\/g, "/").split("/").filter(Boolean);
+function pathSegments(path7) {
+  return path7.replace(/\\/g, "/").split("/").filter(Boolean);
 }
-function basenameOf(path5) {
-  const parts2 = pathSegments(path5);
-  return parts2.at(-1) ?? path5;
+function basenameOf(path7) {
+  const parts2 = pathSegments(path7);
+  return parts2.at(-1) ?? path7;
 }
 function stripExtension(name2) {
   const dot = name2.lastIndexOf(".");
   return dot > 0 ? name2.slice(0, dot) : name2;
 }
-function acronymForPath(path5) {
-  return pathSegments(path5).map((segment) => stripExtension(segment).match(/[A-Za-z0-9]/)?.[0] ?? "").join("").toLowerCase();
+function acronymForPath(path7) {
+  return pathSegments(path7).map((segment) => stripExtension(segment).match(/[A-Za-z0-9]/)?.[0] ?? "").join("").toLowerCase();
 }
-function isConfigPath(path5) {
-  const lower = path5.toLowerCase();
+function isConfigPath(path7) {
+  const lower = path7.toLowerCase();
   return lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".toml") || lower.endsWith(".sql") || lower.endsWith("dockerfile");
 }
-function isMarkdownPath(path5) {
-  const lower = path5.toLowerCase();
+function isMarkdownPath(path7) {
+  const lower = path7.toLowerCase();
   return lower.endsWith(".md") || lower.endsWith(".markdown");
 }
 function attentionRanker(attention) {
@@ -1876,8 +1878,8 @@ function cleanPreview(text) {
   const collapsed = text.replace(/\s+/g, " ").trim();
   return collapsed.length > MAX_PREVIEW_CHARS ? collapsed.slice(0, MAX_PREVIEW_CHARS).trimEnd() + "..." : collapsed;
 }
-function chunkId(path5, startLine, kind, title) {
-  return `${path5}:${startLine}:${kind}:${title}`;
+function chunkId(path7, startLine, kind, title) {
+  return `${path7}:${startLine}:${kind}:${title}`;
 }
 function firstCommentTokens(lines) {
   const picked = [];
@@ -1889,7 +1891,7 @@ function firstCommentTokens(lines) {
   }
   return tokenizeSearchText(picked.join(" "));
 }
-function makeChunk(path5, lines, startLine, endLine, kind, title) {
+function makeChunk(path7, lines, startLine, endLine, kind, title) {
   const safeStart = Math.max(1, startLine);
   const safeEnd = Math.max(safeStart, Math.min(lines.length, endLine));
   const slice = lines.slice(safeStart - 1, safeEnd);
@@ -1899,12 +1901,12 @@ function makeChunk(path5, lines, startLine, endLine, kind, title) {
   const commentTokens = firstCommentTokens(slice);
   if (tokens.length === 0 && titleTokens.length === 0) return null;
   return {
-    id: chunkId(path5, safeStart, kind, title || path5),
-    path: path5,
+    id: chunkId(path7, safeStart, kind, title || path7),
+    path: path7,
     startLine: safeStart,
     endLine: safeEnd,
     kind,
-    title: title || path5,
+    title: title || path7,
     preview: cleanPreview(text),
     tokens,
     titleTokens,
@@ -1918,7 +1920,7 @@ function frontmatterValue(block, field) {
   }
   return "";
 }
-function frontmatterChunk(path5, lines) {
+function frontmatterChunk(path7, lines) {
   if ((lines[0] ?? "").trim() !== "---") return null;
   let close = -1;
   for (let i2 = 1; i2 < Math.min(lines.length, 60); i2++) {
@@ -1931,9 +1933,9 @@ function frontmatterChunk(path5, lines) {
   const block = lines.slice(1, close).map((line) => line.replace(/\r$/, ""));
   const facets = ["type", "title", "name", "description", "tags"].map((field) => frontmatterValue(block, field)).filter((value) => value.length > 0);
   if (facets.length === 0) return null;
-  return makeChunk(path5, lines, 1, close + 1, "frontmatter", facets.join(" \u2014 "));
+  return makeChunk(path7, lines, 1, close + 1, "frontmatter", facets.join(" \u2014 "));
 }
-function buildChunksForFile(path5, content, symbols, fileSummary) {
+function buildChunksForFile(path7, content, symbols, fileSummary) {
   const lines = content.split("\n");
   const chunks = [];
   const sorted = [...symbols].sort((a, b) => a.line - b.line);
@@ -1941,8 +1943,8 @@ function buildChunksForFile(path5, content, symbols, fileSummary) {
     const headerEnd = sorted[0].line - 1;
     for (let start2 = 1; start2 <= headerEnd; start2 += WINDOW_LINES - WINDOW_OVERLAP) {
       const end = Math.min(headerEnd, start2 + WINDOW_LINES - 1);
-      const title = start2 === 1 && fileSummary ? fileSummary : `${path5}:${start2}-${end}`;
-      const chunk = makeChunk(path5, lines, start2, end, "window", title);
+      const title = start2 === 1 && fileSummary ? fileSummary : `${path7}:${start2}-${end}`;
+      const chunk = makeChunk(path7, lines, start2, end, "window", title);
       if (chunk) chunks.push(chunk);
       if (end >= headerEnd) break;
     }
@@ -1952,25 +1954,25 @@ function buildChunksForFile(path5, content, symbols, fileSummary) {
     const next = sorted[i2 + 1];
     const end = next ? Math.max(sym.line, next.line - 1) : lines.length;
     const kind = ["function", "method", "class"].includes(sym.kind) ? sym.kind : "module";
-    const chunk = makeChunk(path5, lines, sym.line, end, kind, sym.signature || sym.name);
+    const chunk = makeChunk(path7, lines, sym.line, end, kind, sym.signature || sym.name);
     if (chunk) chunks.push(chunk);
   }
-  if (isMarkdownPath(path5)) {
-    const fmChunk = frontmatterChunk(path5, lines);
+  if (isMarkdownPath(path7)) {
+    const fmChunk = frontmatterChunk(path7, lines);
     if (fmChunk) chunks.push(fmChunk);
     const headingLines = lines.map((line, i2) => ({ line, i: i2 + 1 })).filter((x) => /^#{1,6}\s+/.test(x.line));
     for (let i2 = 0; i2 < headingLines.length; i2++) {
       const h = headingLines[i2];
       const end = headingLines[i2 + 1] ? headingLines[i2 + 1].i - 1 : lines.length;
-      const chunk = makeChunk(path5, lines, h.i, end, "markdown_section", h.line.replace(/^#+\s*/, ""));
+      const chunk = makeChunk(path7, lines, h.i, end, "markdown_section", h.line.replace(/^#+\s*/, ""));
       if (chunk) chunks.push(chunk);
     }
   }
-  if (chunks.length === 0 || isConfigPath(path5)) {
+  if (chunks.length === 0 || isConfigPath(path7)) {
     for (let start2 = 1; start2 <= lines.length; start2 += WINDOW_LINES - WINDOW_OVERLAP) {
       const end = Math.min(lines.length, start2 + WINDOW_LINES - 1);
-      const title = start2 === 1 && fileSummary ? fileSummary : `${path5}:${start2}-${end}`;
-      const chunk = makeChunk(path5, lines, start2, end, isConfigPath(path5) ? "config" : "window", title);
+      const title = start2 === 1 && fileSummary ? fileSummary : `${path7}:${start2}-${end}`;
+      const chunk = makeChunk(path7, lines, start2, end, isConfigPath(path7) ? "config" : "window", title);
       if (chunk) chunks.push(chunk);
       if (end >= lines.length) break;
     }
@@ -2006,17 +2008,17 @@ var ContentChunkIndex = class _ContentChunkIndex {
     this.clear();
     for (const chunk of chunks) this.insert(chunk);
   }
-  replacePath(path5, chunks) {
+  replacePath(path7, chunks) {
     this.membershipMemo.clear();
-    this.removePath(path5);
+    this.removePath(path7);
     for (const chunk of chunks) this.insert(chunk);
   }
-  removePath(path5) {
+  removePath(path7) {
     this.membershipMemo.clear();
-    const ids = this.chunksByPath.get(path5);
+    const ids = this.chunksByPath.get(path7);
     if (!ids) return;
     for (const id of ids) this.removeChunk(id);
-    this.chunksByPath.delete(path5);
+    this.chunksByPath.delete(path7);
   }
   size() {
     return this.chunks.size;
@@ -2126,8 +2128,8 @@ var ContentChunkIndex = class _ContentChunkIndex {
     }
     return hits.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path) || a.startLine - b.startLine).slice(0, options.limit ?? 20);
   }
-  bestChunksForPath(path5, limit = 3) {
-    return [...this.chunksByPath.get(path5) ?? []].map((id) => this.chunks.get(id)).filter((c) => Boolean(c)).sort((a, b) => a.startLine - b.startLine).slice(0, limit).map((c) => this.toIndexedChunk(c));
+  bestChunksForPath(path7, limit = 3) {
+    return [...this.chunksByPath.get(path7) ?? []].map((id) => this.chunks.get(id)).filter((c) => Boolean(c)).sort((a, b) => a.startLine - b.startLine).slice(0, limit).map((c) => this.toIndexedChunk(c));
   }
   /** Reconstruct the IndexedChunk shape (token multiset from interned term
    *  frequencies — order-insensitive by contract) for the handful of chunks
@@ -2230,8 +2232,8 @@ function computeRelatedPaths(touched, dependentsOf, limit = 16) {
   const touchedSet = new Set(touched.map((p) => p.trim()).filter((p) => p.length > 0));
   const related = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const path5 of touchedSet) {
-    for (const dep of dependentsOf(path5)) {
+  for (const path7 of touchedSet) {
+    for (const dep of dependentsOf(path7)) {
       const d = dep.trim();
       if (!d || touchedSet.has(d) || seen.has(d)) continue;
       seen.add(d);
@@ -2242,31 +2244,31 @@ function computeRelatedPaths(touched, dependentsOf, limit = 16) {
   return related;
 }
 function indexDependents(index, perSymbolLimit = 20) {
-  return (path5) => {
+  return (path7) => {
     const out2 = [];
     const seen = /* @__PURE__ */ new Set();
     const add = (edges) => {
       for (const edge of edges) {
         const src = edge.source_path;
-        if (src && src !== path5 && !seen.has(src)) {
+        if (src && src !== path7 && !seen.has(src)) {
           seen.add(src);
           out2.push(src);
         }
       }
     };
-    for (const symbol of index.byPath.get(path5) ?? []) {
+    for (const symbol of index.byPath.get(path7) ?? []) {
       add(index.findCallers(symbol.name, { limit: perSymbolLimit }));
     }
-    const moduleName = path5.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "";
+    const moduleName = path7.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "";
     if (moduleName) add(index.findImporters(moduleName, { limit: perSymbolLimit }));
     return out2;
   };
 }
 
 // ../packages/orion-client-core/src/pathIndex.ts
-function isConfigOrDocPath(path5) {
-  if (isConfigPath(path5) || isMarkdownPath(path5)) return true;
-  const lower = path5.toLowerCase();
+function isConfigOrDocPath(path7) {
+  if (isConfigPath(path7) || isMarkdownPath(path7)) return true;
+  const lower = path7.toLowerCase();
   return lower.endsWith(".sh") || lower.endsWith(".bash") || lower.includes("/.github/") || lower.includes("/.gitlab/");
 }
 var PathIndex = class {
@@ -2276,29 +2278,29 @@ var PathIndex = class {
   }
   replace(paths, meta) {
     this.clear();
-    for (const path5 of paths) this.upsert(path5, meta.get(path5));
+    for (const path7 of paths) this.upsert(path7, meta.get(path7));
   }
-  upsert(path5, meta) {
-    const basename = basenameOf(path5);
+  upsert(path7, meta) {
+    const basename = basenameOf(path7);
     const basenameStem = stripExtension(basename);
-    const segments = pathSegments(path5);
+    const segments = pathSegments(path7);
     const tokens = /* @__PURE__ */ new Set();
-    for (const value of [path5, basename, basenameStem, ...segments]) {
+    for (const value of [path7, basename, basenameStem, ...segments]) {
       for (const token of tokenizeIdentifier(value)) tokens.add(token);
     }
-    this.entries.set(path5, {
-      path: path5,
-      lowerPath: path5.toLowerCase(),
+    this.entries.set(path7, {
+      path: path7,
+      lowerPath: path7.toLowerCase(),
       basename: basename.toLowerCase(),
       basenameStem: basenameStem.toLowerCase(),
       segments: segments.map((s) => s.toLowerCase()),
       tokens,
-      acronym: acronymForPath(path5),
+      acronym: acronymForPath(path7),
       meta
     });
   }
-  remove(path5) {
-    this.entries.delete(path5);
+  remove(path7) {
+    this.entries.delete(path7);
   }
   size() {
     return this.entries.size;
@@ -2646,27 +2648,27 @@ var KNOWN_EDGE_KINDS = /* @__PURE__ */ new Set([
   "implements",
   "references"
 ]);
-function isTestPath(path5) {
-  const p = "/" + path5.toLowerCase();
+function isTestPath(path7) {
+  const p = "/" + path7.toLowerCase();
   if (TEST_SUBSTRINGS.some((s) => p.includes(s))) return true;
-  const base = path5.toLowerCase().split("/").pop() ?? "";
+  const base = path7.toLowerCase().split("/").pop() ?? "";
   return base.startsWith("test_") || base.endsWith("_test.go");
 }
-function isGeneratedPath(path5) {
-  const lower = path5.toLowerCase();
+function isGeneratedPath(path7) {
+  const lower = path7.toLowerCase();
   const p = "/" + lower;
   return GENERATED_SUBSTRINGS.some((s) => p.includes(s)) || GENERATED_SUFFIXES.some((s) => lower.endsWith(s));
 }
-function pathStems(path5) {
-  const parts2 = path5.replace(/\\/g, "/").split("/").filter(Boolean);
+function pathStems(path7) {
+  const parts2 = path7.replace(/\\/g, "/").split("/").filter(Boolean);
   if (parts2.length === 0) return [];
   const last = parts2[parts2.length - 1];
   const dot = last.lastIndexOf(".");
   if (dot > 0) parts2[parts2.length - 1] = last.slice(0, dot);
   return parts2.map((p) => p.toLowerCase()).filter(Boolean);
 }
-function dirnamePath(path5) {
-  const parts2 = path5.replace(/\\/g, "/").split("/");
+function dirnamePath(path7) {
+  const parts2 = path7.replace(/\\/g, "/").split("/");
   parts2.pop();
   return parts2.join("/");
 }
@@ -2680,11 +2682,11 @@ function joinRelPath(base, spec) {
   }
   return out2.join("/");
 }
-function withoutKnownExtension(path5) {
-  return path5.replace(/\.(tsx?|jsx?|mjs|cjs|py|go|rs|java|kt|kts|scala|rb)$/i, "");
+function withoutKnownExtension(path7) {
+  return path7.replace(/\.(tsx?|jsx?|mjs|cjs|py|go|rs|java|kt|kts|scala|rb)$/i, "");
 }
-function normalizeTracePath(path5) {
-  return path5.trim().replace(/\\/g, "/").replace(/^file:\/\//, "").replace(/^\/+/, "").replace(/[:#]L?\d+(?::\d+)?$/, "").replace(/^['"`]|['"`]$/g, "");
+function normalizeTracePath(path7) {
+  return path7.trim().replace(/\\/g, "/").replace(/^file:\/\//, "").replace(/^\/+/, "").replace(/[:#]L?\d+(?::\d+)?$/, "").replace(/^['"`]|['"`]$/g, "");
 }
 function looksPathLike(value) {
   return /[\\/]/.test(value) || /\.[A-Za-z0-9]+(?::\d+)?$/.test(value);
@@ -2721,21 +2723,16 @@ function clampInt(value, fallback, low, high) {
   if (!Number.isFinite(n)) return fallback;
   return Math.max(low, Math.min(high, Math.trunc(n)));
 }
-function scopeFilter(path5, scope) {
+function scopeFilter(path7, scope) {
   const s = String(scope ?? "").trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
   if (!s || s === ".") return true;
-  return path5 === s || path5.startsWith(s + "/");
+  return path7 === s || path7.startsWith(s + "/");
 }
 function detailLimit(detail, brief, normal, deep) {
   if (detail === "brief") return brief;
   if (detail === "deep") return deep;
   return normal;
 }
-var DEFAULT_RETRIEVAL_MODE = "default";
-function normalizeRetrievalMode(value, fallback = DEFAULT_RETRIEVAL_MODE) {
-  if (value === "default" || value === "enhanced") return value;
-  return fallback;
-}
 var CONTENT_PROBE_DEADLINE_MS = 600;
 async function boundedAll(promises2, deadlineMs) {
   if (promises2.length === 0) return [];
@@ -2825,9 +2822,9 @@ function fuseHits(hitLists, topK) {
   for (const hits of hitLists) {
     const votedThisList = /* @__PURE__ */ new Set();
     hits.forEach((hit, i2) => {
-      const path5 = String(hit.path ?? "");
+      const path7 = String(hit.path ?? "");
       const type = String(hit.result_type ?? "match");
-      const key = path5 || `${type}:${i2}`;
+      const key = path7 || `${type}:${i2}`;
       if (votedThisList.has(key)) return;
       votedThisList.add(key);
       scores.set(key, (scores.get(key) ?? 0) + 1 / (60 + i2 + 1));
@@ -2985,8 +2982,8 @@ var WorkspaceIndexStore = class {
       this.setMeta(file, snapshot.file_meta[file]);
     }
     this.pathIndex.replace(this.files, this.fileMeta);
-    for (const [path5, summary] of Object.entries(snapshot.file_summaries)) {
-      if (summary) this.fileSummaries.set(path5, String(summary));
+    for (const [path7, summary] of Object.entries(snapshot.file_summaries)) {
+      if (summary) this.fileSummaries.set(path7, String(summary));
     }
     for (const sym of snapshot.symbols) this.insertSymbol(sym);
     for (const edge of snapshot.edges) this.insertEdge(edge);
@@ -3117,19 +3114,19 @@ var WorkspaceIndexStore = class {
       this.totalFiles = Math.max(this.totalFiles, this.processedFiles);
     }
   }
-  removeFile(path5) {
+  removeFile(path7) {
     this.noteMutation();
     const refreshTargets = /* @__PURE__ */ new Set();
-    for (const sym of this.byPath.get(path5) ?? []) {
+    for (const sym of this.byPath.get(path7) ?? []) {
       const name2 = sym.name.toLowerCase();
       if (name2) refreshTargets.add(name2);
     }
-    for (const stem of this.pathStemsByFile.get(path5) ?? []) {
+    for (const stem of this.pathStemsByFile.get(path7) ?? []) {
       if (stem) refreshTargets.add(stem);
     }
-    this.removePath(path5);
-    this.files.delete(path5);
-    this.removePathStems(path5);
+    this.removePath(path7);
+    this.files.delete(path7);
+    this.removePathStems(path7);
     for (const target of refreshTargets) this.refreshEdgeResolutionForTarget(target);
     this.indexedAt = Date.now() / 1e3;
     if (this.buildState === "empty") this.buildState = "partial";
@@ -3228,11 +3225,11 @@ var WorkspaceIndexStore = class {
     const now = Date.now() / 1e3;
     return filtered.map((s) => [s, this.scoreSymbol(s, needle, needleTokens, options.attention, now)]).sort((a, b) => b[1] - a[1] || a[0].path.localeCompare(b[0].path) || a[0].line - b[0].line).slice(0, options.limit ?? 50);
   }
-  listSymbols(path5) {
-    return [...this.byPath.get(path5) ?? []].sort((a, b) => a.line - b.line);
+  listSymbols(path7) {
+    return [...this.byPath.get(path7) ?? []].sort((a, b) => a.line - b.line);
   }
-  enclosingSymbol(path5, line) {
-    const syms = this.listSymbols(path5);
+  enclosingSymbol(path7, line) {
+    const syms = this.listSymbols(path7);
     let candidate = null;
     let nextStart = null;
     for (const sym of syms) {
@@ -3394,14 +3391,13 @@ var WorkspaceIndexStore = class {
     const missRank = options.attention?.length ?? 0;
     return [...candidates].map((p) => [p, sets.filter((s) => s.has(p)).length]).sort((a, b) => b[1] - a[1] || (attentionRank.get(a[0]) ?? missRank) - (attentionRank.get(b[0]) ?? missRank) || a[0].localeCompare(b[0])).slice(0, options.topK ?? 30);
   }
-  async searchCodebase(input, options = {}) {
+  async searchCodebase(input) {
     const query = String(input.query ?? "").trim();
     if (!query) throw new Error("`query` is required");
     const scope = String(input.scope ?? "").trim() || void 0;
     const detail = ["brief", "normal", "deep"].includes(String(input.detail)) ? String(input.detail) : "normal";
     const intent = String(input.intent ?? "auto");
     const maxResults = clampInt(input.max_results, 8, 1, 25);
-    const retrievalMode = normalizeRetrievalMode(options.retrievalMode);
     const status = this.status();
     if (!status.ready) {
       return [
@@ -3416,8 +3412,8 @@ var WorkspaceIndexStore = class {
     const perSource = Math.max(maxResults, 12);
     const termSets = await this.termFileSets(queryTerms(query));
     const symbols = this.symbolHitsForQuery(query, perSource, attention, scope);
-    const files = retrievalMode === "enhanced" ? this.rankedFileHits(query, perSource, attention, scope, termSets) : this.basicFileHitsForQuery(query, perSource, attention, scope, termSets);
-    const content = await this.contentHitsForQuery(query, perSource, attention, scope, retrievalMode, termSets);
+    const files = this.fileHitsForQuery(query, perSource, attention, scope, termSets);
+    const content = await this.contentHitsForQuery(query, perSource, attention, scope, termSets);
     const seeds = this.graphExpansionSeeds(symbols, files);
     const graph = seeds.length > 0 ? this.graphHitsForQuery(seeds, perSource, scope, queryTerms(query), termSets) : [];
     const merged = fuseHits([symbols, files, content, graph], maxResults);
@@ -3430,7 +3426,7 @@ var WorkspaceIndexStore = class {
       `- query: ${query}`,
       `- intent: ${intent}`,
       `- scope: ${scope ?? "."}`,
-      `- retrieval_mode: ${retrievalMode}`,
+      "- retrieval_level: normal",
       "",
       "Top Files"
     ];
@@ -3460,21 +3456,19 @@ var WorkspaceIndexStore = class {
     let cardRank = 0;
     for (const [p, cardReasons] of topPaths.slice(0, maxResults)) {
       cardRank += 1;
-      lines.push(...this.renderFileCard(p, cardRank, cardReasons, detail, retrievalMode, relatedByPath.get(p)));
-    }
-    if (retrievalMode === "enhanced") {
-      const chunkLimit = detailLimit(detail, 3, 6, 10);
-      const chunkHits = content.filter((hit) => hit.result_type === "chunk").slice(0, chunkLimit);
-      if (chunkHits.length > 0) {
-        lines.push("", "Top Matches");
-        for (const hit of chunkHits) {
-          const reasons = Array.isArray(hit.reasons) ? hit.reasons.map(String).join(", ") : "chunk";
-          lines.push(
-            `- ${hit.path}:${hit.line}-${hit.end_line} [${hit.kind}] ${hit.name} (score=${hit.score}; ${reasons})`
-          );
-          if (hit.preview) lines.push(`  Preview: ${hit.preview}`);
-          lines.push(`  Next read: read_file path=${hit.path} start_line=${hit.line} end_line=${hit.end_line} context=dependencies`);
-        }
+      lines.push(...this.renderFileCard(p, cardRank, cardReasons, detail, relatedByPath.get(p)));
+    }
+    const chunkLimit = detailLimit(detail, 3, 6, 10);
+    const chunkHits = content.filter((hit) => hit.result_type === "chunk").slice(0, chunkLimit);
+    if (chunkHits.length > 0) {
+      lines.push("", "Top Matches");
+      for (const hit of chunkHits) {
+        const reasons = Array.isArray(hit.reasons) ? hit.reasons.map(String).join(", ") : "chunk";
+        lines.push(
+          `- ${hit.path}:${hit.line}-${hit.end_line} [${hit.kind}] ${hit.name} (score=${hit.score}; ${reasons})`
+        );
+        if (hit.preview) lines.push(`  Preview: ${hit.preview}`);
+        lines.push(`  Next read: read_file path=${hit.path} start_line=${hit.line} end_line=${hit.end_line} context=dependencies`);
       }
     }
     const symbolLimit = detailLimit(detail, 3, 6, 10);
@@ -3515,12 +3509,11 @@ var WorkspaceIndexStore = class {
     );
     return lines.join("\n");
   }
-  async traceCodebase(input, options = {}) {
+  async traceCodebase(input) {
     const target = String(input.target ?? "").trim();
     if (!target) throw new Error("`target` is required");
     const parsedTarget = parseTraceTarget(target, input.path);
     const targetName = parsedTarget.name.trim() || target;
-    const retrievalMode = normalizeRetrievalMode(options.retrievalMode);
     const relation = ["auto", "impact", "callers", "importers", "references", "hierarchy", "dependencies"].includes(String(input.relation)) ? String(input.relation) : "auto";
     const scope = String(input.scope ?? "").trim() || void 0;
     const depth = clampInt(input.depth, 2, 1, 6);
@@ -3535,7 +3528,7 @@ var WorkspaceIndexStore = class {
         `Use grep for "${targetName}" until enough files are indexed.`
       ].join("\n");
     }
-    const targets = this.resolveTraceTargets(targetName, scope, 5, parsedTarget.pathHint, retrievalMode);
+    const targets = this.resolveTraceTargets(targetName, scope, 5, parsedTarget.pathHint);
     const selected = targets[0] ?? { name: targetName, path: "", line: 1, kind: "unknown", score: 0 };
     const selectedName = String(selected.name || targetName).split(".").pop() ?? targetName;
     const selectedPath = String(selected.path || "");
@@ -3611,7 +3604,7 @@ var WorkspaceIndexStore = class {
       }
     }
     if (structuralHitCount === 0) {
-      lines.push("", ...await this.formatTraceFallback(selectedName, selectedPath, scope, detailLimit("normal", 3, 6, 10), retrievalMode));
+      lines.push("", ...await this.formatTraceFallback(selectedName, selectedPath, scope, detailLimit("normal", 3, 6, 10)));
     }
     const suggested = dedupe(
       [
@@ -3638,13 +3631,12 @@ var WorkspaceIndexStore = class {
     }
     return lines.join("\n");
   }
-  async readContextHeader(path5, startLine, mode, options = {}) {
+  async readContextHeader(path7, startLine, mode) {
     if (mode === "none" || !this.status().ready) return "";
-    const retrievalMode = normalizeRetrievalMode(options.retrievalMode);
-    const summary = this.fileSummaryFor(path5);
-    const syms = this.listSymbols(path5);
-    const imports = [...this.edgesOutByPath.get(path5) ?? []].filter((e) => e.kind === "imports" && e.target).map((e) => e.target);
-    const enclosing = this.enclosingSymbol(path5, startLine);
+    const summary = this.fileSummaryFor(path7);
+    const syms = this.listSymbols(path7);
+    const imports = [...this.edgesOutByPath.get(path7) ?? []].filter((e) => e.kind === "imports" && e.target).map((e) => e.target);
+    const enclosing = this.enclosingSymbol(path7, startLine);
     let parentClass = null;
     if (enclosing && (enclosing[0].kind === "function" || enclosing[0].kind === "method")) {
       for (const sym of syms) {
@@ -3654,7 +3646,7 @@ var WorkspaceIndexStore = class {
     }
     if (!summary && !parentClass && !enclosing && imports.length === 0 && syms.length === 0) return "";
     const lines = ["--- codebase context ---"];
-    if (summary) lines.push(`file: ${path5} - ${summary}`);
+    if (summary) lines.push(`file: ${path7} - ${summary}`);
     if (parentClass) lines.push(`class: ${parentClass.path}:${parentClass.line} [${parentClass.kind}] ${parentClass.signature || parentClass.name}`);
     if (enclosing) {
       const [sym, end] = enclosing;
@@ -3675,13 +3667,13 @@ var WorkspaceIndexStore = class {
       }
     }
     if (["dependencies", "full", "auto"].includes(mode)) {
-      const related = await this.relatedContextForPath(path5, mode === "full" ? 8 : 4);
+      const related = await this.relatedContextForPath(path7, mode === "full" ? 8 : 4);
       if (related.dependencies.length > 0) lines.push(`depends on: ${related.dependencies.join(", ")}`);
       if (related.dependents.length > 0) lines.push(`used by: ${related.dependents.join(", ")}`);
       if (related.tests.length > 0) lines.push(`related tests: ${related.tests.join(", ")}`);
     }
-    if (retrievalMode === "enhanced" && mode === "full" && this.chunkIndex.size() > 0) {
-      const chunks = this.chunkIndex.bestChunksForPath(path5, 4);
+    if (mode === "full" && this.chunkIndex.size() > 0) {
+      const chunks = this.chunkIndex.bestChunksForPath(path7, 4);
       if (chunks.length > 0) {
         lines.push(`chunks: ${chunks.map((c) => `${c.title}@${c.startLine}-${c.endLine}`).join(", ")}`);
       }
@@ -3707,34 +3699,28 @@ var WorkspaceIndexStore = class {
     }
     return hits;
   }
-  rankedFileHits(query, limit, attention, scope, termSets) {
-    return this.fileHitsForQuery(query, limit, attention, scope, true, termSets);
-  }
-  basicFileHitsForQuery(query, limit, attention, scope, termSets) {
-    return this.fileHitsForQuery(query, limit, attention, scope, false, termSets);
-  }
-  fileHitsForQuery(query, limit, attention, scope, includePathIndex, termSets) {
+  fileHitsForQuery(query, limit, attention, scope, termSets) {
     const terms = queryTerms(query);
     const queryLc = query.toLowerCase().trim();
     const hits = [];
-    const pathHits = includePathIndex ? new Map(
+    const pathHits = new Map(
       this.pathIndex.search(query, { limit: Math.max(limit * 4, 50), scope, attention, includeDocs: true }).map((hit) => [hit.path, hit])
-    ) : /* @__PURE__ */ new Map();
+    );
     if (/[*?[\]]/.test(query)) {
-      for (const path5 of this.findFiles(query, limit * 2)) {
-        if (scopeFilter(path5, scope)) hits.push([100, path5, ["glob"]]);
+      for (const path7 of this.findFiles(query, limit * 2)) {
+        if (scopeFilter(path7, scope)) hits.push([100, path7, ["glob"]]);
       }
       if (hits.length > 0) {
-        return hits.sort((a, b) => b[0] - a[0] || a[1].localeCompare(b[1])).slice(0, limit).map(([score, path5, reasons]) => ({ result_type: "file", path: path5, score, reasons }));
+        return hits.sort((a, b) => b[0] - a[0] || a[1].localeCompare(b[1])).slice(0, limit).map(([score, path7, reasons]) => ({ result_type: "file", path: path7, score, reasons }));
       }
     }
-    for (const path5 of this.files) {
-      if (!scopeFilter(path5, scope)) continue;
+    for (const path7 of this.files) {
+      if (!scopeFilter(path7, scope)) continue;
       let score = 0;
       const reasons = [];
-      const pathLc = path5.toLowerCase();
-      const summaryLc = (this.fileSummaries.get(path5) ?? "").toLowerCase();
-      const pathHit = pathHits.get(path5);
+      const pathLc = path7.toLowerCase();
+      const summaryLc = (this.fileSummaries.get(path7) ?? "").toLowerCase();
+      const pathHit = pathHits.get(path7);
       if (pathHit) {
         score += pathHit.score;
         reasons.push(...pathHit.reasons);
@@ -3752,24 +3738,24 @@ var WorkspaceIndexStore = class {
           score += 8;
           if (!reasons.includes("summary")) reasons.push("summary");
         }
-        if (termSets.get(term)?.has(path5)) {
+        if (termSets.get(term)?.has(path7)) {
           score += 5;
           if (!reasons.includes("content")) reasons.push("content");
         }
       }
-      if (attention?.includes(path5)) {
-        score += attention.indexOf(path5) === 0 ? 20 : 10;
+      if (attention?.includes(path7)) {
+        score += attention.indexOf(path7) === 0 ? 20 : 10;
         reasons.push("open/recent");
       }
-      const meta = this.fileMeta.get(path5);
+      const meta = this.fileMeta.get(path7);
       if (meta?.is_generated) score -= 50;
       if (meta?.is_test) score -= 12;
-      if (score > 0) hits.push([score, path5, reasons]);
+      if (score > 0) hits.push([score, path7, reasons]);
     }
-    return hits.sort((a, b) => b[0] - a[0] || a[1].localeCompare(b[1])).slice(0, limit).map(([score, path5, reasons]) => ({ result_type: "file", path: path5, score, reasons }));
+    return hits.sort((a, b) => b[0] - a[0] || a[1].localeCompare(b[1])).slice(0, limit).map(([score, path7, reasons]) => ({ result_type: "file", path: path7, score, reasons }));
   }
-  async contentHitsForQuery(query, limit, attention, scope, retrievalMode, termSets) {
-    if (retrievalMode === "enhanced" && this.chunkIndex.size() > 0) {
+  async contentHitsForQuery(query, limit, attention, scope, termSets) {
+    if (this.chunkIndex.size() > 0) {
       return this.chunkIndex.search(query, { limit, scope, attention, meta: this.fileMeta }).map((hit) => ({
         result_type: "chunk",
         path: hit.path,
@@ -3786,21 +3772,21 @@ var WorkspaceIndexStore = class {
     if (terms.length === 0) return [];
     const hits = await this.findFilesMentioning(terms, { topK: limit * 3, attention, termSets });
     const out2 = [];
-    for (const [path5, count] of hits) {
-      if (!scopeFilter(path5, scope)) continue;
-      out2.push({ result_type: "content", path: path5, hits: count });
+    for (const [path7, count] of hits) {
+      if (!scopeFilter(path7, scope)) continue;
+      out2.push({ result_type: "content", path: path7, hits: count });
       if (out2.length >= limit) break;
     }
     return out2;
   }
-  resolveTraceTargets(target, scope, limit, pathHint, retrievalMode) {
-    const scopedFiles = pathHint ? this.matchFilesForPathHint(pathHint, scope, limit * 4, retrievalMode) : [];
+  resolveTraceTargets(target, scope, limit, pathHint) {
+    const scopedFiles = pathHint ? this.matchFilesForPathHint(pathHint, scope, limit * 4) : [];
     if (scopedFiles.length > 0) {
       const needle = target.toLowerCase().trim();
       const needleTokens = tokenizeName(target);
       const symbolHits = [];
-      for (const path5 of scopedFiles) {
-        for (const sym of this.listSymbols(path5)) {
+      for (const path7 of scopedFiles) {
+        for (const sym of this.listSymbols(path7)) {
           const name2 = sym.name.toLowerCase();
           const tokens = this.tokensByName.get(name2) ?? tokenizeName(sym.name);
           let overlap = 0;
@@ -3827,15 +3813,13 @@ var WorkspaceIndexStore = class {
     }
     const candidates = this.symbolHitsForQuery(target, limit, void 0, scope);
     if (candidates.length > 0) return candidates;
-    return this.matchFilesForPathHint(target, scope, limit, retrievalMode).map((p) => ({ path: p, name: (p.split("/").pop() ?? p).split(".")[0], line: 1, kind: "file", score: 0 }));
+    return this.matchFilesForPathHint(target, scope, limit).map((p) => ({ path: p, name: (p.split("/").pop() ?? p).split(".")[0], line: 1, kind: "file", score: 0 }));
   }
-  matchFilesForPathHint(pathHint, scope, limit, retrievalMode) {
+  matchFilesForPathHint(pathHint, scope, limit) {
     const hint = normalizeTracePath(pathHint).toLowerCase();
     if (!hint) return [];
-    if (retrievalMode === "enhanced") {
-      const pathHits = this.pathIndex.search(hint, { scope, limit: limit * 2 });
-      if (pathHits.length > 0) return pathHits.slice(0, limit).map((h) => h.path);
-    }
+    const pathHits = this.pathIndex.search(hint, { scope, limit: limit * 2 });
+    if (pathHits.length > 0) return pathHits.slice(0, limit).map((h) => h.path);
     return [...this.files].filter((p) => scopeFilter(p, scope)).map((p) => {
       const lc = p.toLowerCase();
       let score = 0;
@@ -3846,30 +3830,28 @@ var WorkspaceIndexStore = class {
       return [p, score];
     }).filter(([, score]) => score > 0).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([p]) => p);
   }
-  async formatTraceFallback(target, selectedPath, scope, limit, retrievalMode) {
-    if (retrievalMode === "enhanced") {
-      const chunkHits = this.chunkIndex.search(target, { limit, scope, meta: this.fileMeta }).filter((hit) => hit.path !== selectedPath);
-      if (chunkHits.length > 0) {
-        return [
-          "Trace Coverage",
-          "- no structural edges were indexed for this target/relation",
-          "- fallback: showing ranked chunk evidence from the same client index",
-          "",
-          "Possible Indexed Mentions",
-          ...chunkHits.map(
-            (hit) => `- ${hit.path}:${hit.startLine}-${hit.endLine} ${hit.title} (score=${hit.score}; ${hit.reasons.join(", ")})
+  async formatTraceFallback(target, selectedPath, scope, limit) {
+    const chunkHits = this.chunkIndex.search(target, { limit, scope, meta: this.fileMeta }).filter((hit) => hit.path !== selectedPath);
+    if (chunkHits.length > 0) {
+      return [
+        "Trace Coverage",
+        "- no structural edges were indexed for this target/relation",
+        "- fallback: showing ranked chunk evidence from the same client index",
+        "",
+        "Possible Indexed Mentions",
+        ...chunkHits.map(
+          (hit) => `- ${hit.path}:${hit.startLine}-${hit.endLine} ${hit.title} (score=${hit.score}; ${hit.reasons.join(", ")})
   Preview: ${hit.preview}
   Exact read if needed: read_file path=${hit.path} start_line=${hit.startLine} end_line=${hit.endLine} context=dependencies`
-          )
-        ];
-      }
+        )
+      ];
     }
     const terms = queryTerms(target);
     const exact = target.toLowerCase().trim();
     if (exact && !terms.includes(exact)) terms.unshift(exact);
     const compact = exact.replace(/[^a-z0-9]/g, "");
     if (compact && !terms.includes(compact)) terms.push(compact);
-    const mentions = (await this.findFilesMentioning(terms, { topK: limit * 4 })).filter(([path5]) => path5 !== selectedPath && scopeFilter(path5, scope)).slice(0, limit);
+    const mentions = (await this.findFilesMentioning(terms, { topK: limit * 4 })).filter(([path7]) => path7 !== selectedPath && scopeFilter(path7, scope)).slice(0, limit);
     const lines = [
       "Trace Coverage",
       "- no structural edges were indexed for this target/relation",
@@ -3881,22 +3863,22 @@ var WorkspaceIndexStore = class {
       lines.push("- none indexed; use grep for exact byte-level search");
       return lines;
     }
-    for (const [path5, count] of mentions) {
-      const syms = this.listSymbols(path5).slice(0, 3);
-      const outgoing = (this.edgesOutByPath.get(path5) ?? []).filter((e) => e.target === exact || terms.includes(e.target) || e.source_name.toLowerCase().includes(exact)).slice(0, 3);
+    for (const [path7, count] of mentions) {
+      const syms = this.listSymbols(path7).slice(0, 3);
+      const outgoing = (this.edgesOutByPath.get(path7) ?? []).filter((e) => e.target === exact || terms.includes(e.target) || e.source_name.toLowerCase().includes(exact)).slice(0, 3);
       const details = [`content_hits=${count}`];
       if (syms.length > 0) details.push(`symbols=${syms.map((s) => `${s.name}@${s.line}`).join(",")}`);
       if (outgoing.length > 0) details.push(`edges=${outgoing.map((e) => `${e.kind}:${e.target}@${e.line}`).join(",")}`);
       const firstLine = syms[0]?.line ?? 1;
-      lines.push(`- ${path5} (${details.join("; ")})`);
-      lines.push(`  Exact read if needed: read_file path=${path5} start_line=${firstLine} context=dependencies`);
+      lines.push(`- ${path7} (${details.join("; ")})`);
+      lines.push(`  Exact read if needed: read_file path=${path7} start_line=${firstLine} context=dependencies`);
     }
     return lines;
   }
-  async relatedContextForPath(path5, limit) {
-    const imports = (this.edgesOutByPath.get(path5) ?? []).filter((e) => e.kind === "imports" && e.target).map((e) => e.target);
-    const dependencies = (this.edgesOutByPath.get(path5) ?? []).filter((e) => e.kind !== "imports" && e.target).map((e) => `${e.kind}:${e.target}`);
-    const syms = this.listSymbols(path5);
+  async relatedContextForPath(path7, limit) {
+    const imports = (this.edgesOutByPath.get(path7) ?? []).filter((e) => e.kind === "imports" && e.target).map((e) => e.target);
+    const dependencies = (this.edgesOutByPath.get(path7) ?? []).filter((e) => e.kind !== "imports" && e.target).map((e) => `${e.kind}:${e.target}`);
+    const syms = this.listSymbols(path7);
     const dependentEdges = [];
     for (const sym of syms.slice(0, 8)) {
       dependentEdges.push(...this.findCallers(sym.name, { limit }));
@@ -3904,17 +3886,17 @@ var WorkspaceIndexStore = class {
       dependentEdges.push(...this.findImporters(sym.name, { limit }));
     }
     const dependentPaths = dedupe(dependentEdges, edgeKey, limit * 2).map((e) => e.source_path);
-    for (const token of pathStems(path5)) {
+    for (const token of pathStems(path7)) {
       dependentPaths.push(...this.findImporters(token, { limit }).map((e) => e.source_path));
     }
     const symbolNames = new Set(syms.slice(0, 8).map((s) => s.name.toLowerCase()));
-    const stems = new Set(pathStems(path5));
+    const stems = new Set(pathStems(path7));
     const symbolSets = new Map(
       [...symbolNames].map((n) => [n, this.chunkIndex.filesWithTerm(n)])
     );
     const tests = [];
     for (const [candidate, c] of this.testFileCandidatesFor()) {
-      if (candidate === path5) continue;
+      if (candidate === path7) continue;
       if ([...stems].some((t) => c.includes(t)) || [...symbolNames].some((n) => c.includes(n)) || [...symbolNames].some((n) => symbolSets.get(n)?.has(candidate) ?? false)) {
         tests.push(candidate);
       }
@@ -3923,7 +3905,7 @@ var WorkspaceIndexStore = class {
       imports: dedupe(imports, (p) => p, limit),
       dependencies: dedupe(dependencies, (p) => p, limit),
       // Self-references (recursion, same-file calls) are not dependents.
-      dependents: dedupe(dependentPaths.filter((p) => p !== path5), (p) => p, limit),
+      dependents: dedupe(dependentPaths.filter((p) => p !== path7), (p) => p, limit),
       tests: dedupe(tests, (p) => p, limit)
     };
   }
@@ -4001,13 +3983,13 @@ var WorkspaceIndexStore = class {
       reasons: [c.reason]
     }));
   }
-  renderFileCard(path5, rank, reasons, detail, retrievalMode, related) {
+  renderFileCard(path7, rank, reasons, detail, related) {
     const maxRelated = detailLimit(detail, 2, 4, 7);
-    const lines = [`${rank}. ${path5}`];
+    const lines = [`${rank}. ${path7}`];
     if (reasons.length > 0) lines.push(`   Why: ${dedupe(reasons, (r) => r, 6).join(", ")}`);
-    const summary = this.fileSummaryFor(path5);
+    const summary = this.fileSummaryFor(path7);
     if (summary) lines.push(`   Summary: ${summary}`);
-    const syms = this.listSymbols(path5);
+    const syms = this.listSymbols(path7);
     if (syms.length > 0) {
       const shown = syms.slice(0, maxRelated).map((s) => `${s.signature || s.name}@${s.line}`);
       const tail = syms.length > shown.length ? ` (+${syms.length - shown.length} more)` : "";
@@ -4017,7 +3999,7 @@ var WorkspaceIndexStore = class {
     const dependencies = related.dependencies.slice(0, maxRelated);
     const dependents = related.dependents.slice(0, maxRelated);
     const relatedTests = related.tests.slice(0, maxRelated);
-    const chunks = retrievalMode === "enhanced" ? this.chunkIndex.bestChunksForPath(path5, detail === "deep" ? 3 : 2) : [];
+    const chunks = this.chunkIndex.bestChunksForPath(path7, detail === "deep" ? 3 : 2);
     if (chunks.length > 0) {
       lines.push(`   Chunks: ${chunks.map((c) => `${c.title}@${c.startLine}-${c.endLine}`).join(", ")}`);
     }
@@ -4025,7 +4007,7 @@ var WorkspaceIndexStore = class {
     if (dependencies.length > 0) lines.push(`   Uses: ${dependencies.join(", ")}`);
     if (dependents.length > 0) lines.push(`   Used by: ${dependents.join(", ")}`);
     if (relatedTests.length > 0) lines.push(`   Related tests: ${relatedTests.join(", ")}`);
-    lines.push(syms.length > 0 ? `   Exact read if needed: read_file path=${path5} start_line=${syms[0].line} context=dependencies` : `   Exact read if needed: read_file path=${path5} context=dependencies`);
+    lines.push(syms.length > 0 ? `   Exact read if needed: read_file path=${path7} start_line=${syms[0].line} context=dependencies` : `   Exact read if needed: read_file path=${path7} context=dependencies`);
     return lines;
   }
   formatEdges(title, edges, limit) {
@@ -4043,10 +4025,10 @@ var WorkspaceIndexStore = class {
     const s = this.status();
     return `ready=${s.ready} state=${s.state} progress=${s.progress_percent}% files=${s.file_count} symbols=${s.symbol_count} edges=${s.edge_count} resolved_edges=${s.resolved_edge_count} chunks=${this.chunkIndex.size()}`;
   }
-  fileSummaryFor(path5) {
-    const summary = (this.fileSummaries.get(path5) ?? "").trim();
+  fileSummaryFor(path7) {
+    const summary = (this.fileSummaries.get(path7) ?? "").trim();
     if (summary) return summary;
-    const syms = this.listSymbols(path5);
+    const syms = this.listSymbols(path7);
     if (syms.length === 0) return "";
     const names = syms.map((s) => s.name).filter((n) => !n.startsWith("_"));
     const shown = (names.length > 0 ? names : syms.map((s) => s.name)).slice(0, 5);
@@ -4234,20 +4216,20 @@ var WorkspaceIndexStore = class {
     }
     return null;
   }
-  removePath(path5) {
-    this.removePathStems(path5);
-    this.pathIndex.remove(path5);
-    this.chunkIndex.removePath(path5);
-    const prev = this.byPath.get(path5) ?? [];
-    this.byPath.delete(path5);
-    this.removeEdgesFromPath(path5);
-    this.fileMeta.delete(path5);
-    this.fileSummaries.delete(path5);
+  removePath(path7) {
+    this.removePathStems(path7);
+    this.pathIndex.remove(path7);
+    this.chunkIndex.removePath(path7);
+    const prev = this.byPath.get(path7) ?? [];
+    this.byPath.delete(path7);
+    this.removeEdgesFromPath(path7);
+    this.fileMeta.delete(path7);
+    this.fileSummaries.delete(path7);
     for (const sym of prev) {
       const key = sym.name.toLowerCase();
       const bucket = this.byName.get(key);
       if (!bucket) continue;
-      const next = bucket.filter((s) => s.path !== path5);
+      const next = bucket.filter((s) => s.path !== path7);
       if (next.length > 0) {
         this.byName.set(key, next);
       } else {
@@ -4266,9 +4248,9 @@ var WorkspaceIndexStore = class {
     }
     this.totalSymbols = Math.max(0, this.totalSymbols - prev.length);
   }
-  removeEdgesFromPath(path5) {
-    const outgoing = this.edgesOutByPath.get(path5) ?? [];
-    this.edgesOutByPath.delete(path5);
+  removeEdgesFromPath(path7) {
+    const outgoing = this.edgesOutByPath.get(path7) ?? [];
+    this.edgesOutByPath.delete(path7);
     if (outgoing.length === 0) return;
     const dropsByTarget = /* @__PURE__ */ new Map();
     for (const edge of outgoing) {
@@ -4285,48 +4267,48 @@ var WorkspaceIndexStore = class {
     this.totalEdges = Math.max(0, this.totalEdges - outgoing.length);
     this.totalResolvedEdges = Math.max(0, this.totalResolvedEdges - outgoing.filter((e) => (e.confidence || "AMBIGUOUS") !== "AMBIGUOUS").length);
   }
-  setMeta(path5, override) {
-    this.fileMeta.set(path5, {
+  setMeta(path7, override) {
+    this.fileMeta.set(path7, {
       mtime: override?.mtime ?? 0,
       size: override?.size ?? 0,
-      is_test: Boolean(override?.is_test) || isTestPath(path5),
-      is_generated: Boolean(override?.is_generated) || isGeneratedPath(path5)
+      is_test: Boolean(override?.is_test) || isTestPath(path7),
+      is_generated: Boolean(override?.is_generated) || isGeneratedPath(path7)
     });
   }
   suggestPaths(query, limit = 5) {
     return this.pathIndex.search(query, { limit, includeDocs: true }).map((hit) => hit.path);
   }
-  readRangeSuggestions(path5, limit = 5) {
-    return this.chunkIndex.bestChunksForPath(path5, limit).map((chunk) => ({
+  readRangeSuggestions(path7, limit = 5) {
+    return this.chunkIndex.bestChunksForPath(path7, limit).map((chunk) => ({
       startLine: chunk.startLine,
       endLine: chunk.endLine,
       title: chunk.title
     }));
   }
-  indexPathStems(path5) {
-    const stems = pathStems(path5);
-    this.pathStemsByFile.set(path5, stems);
+  indexPathStems(path7) {
+    const stems = pathStems(path7);
+    this.pathStemsByFile.set(path7, stems);
     const final = stems.at(-1);
     if (final) {
       if (!this.filesByFinalStem.has(final)) this.filesByFinalStem.set(final, /* @__PURE__ */ new Set());
-      this.filesByFinalStem.get(final).add(path5);
+      this.filesByFinalStem.get(final).add(path7);
     }
   }
-  removePathStems(path5) {
-    const stems = this.pathStemsByFile.get(path5);
-    this.pathStemsByFile.delete(path5);
+  removePathStems(path7) {
+    const stems = this.pathStemsByFile.get(path7);
+    this.pathStemsByFile.delete(path7);
     const final = stems?.at(-1);
     if (!final) return;
     const bucket = this.filesByFinalStem.get(final);
     if (!bucket) return;
-    bucket.delete(path5);
+    bucket.delete(path7);
     if (bucket.size === 0) this.filesByFinalStem.delete(final);
   }
-  stemsForPath(path5) {
-    const existing = this.pathStemsByFile.get(path5);
+  stemsForPath(path7) {
+    const existing = this.pathStemsByFile.get(path7);
     if (existing) return existing;
-    this.indexPathStems(path5);
-    return this.pathStemsByFile.get(path5) ?? [];
+    this.indexPathStems(path7);
+    return this.pathStemsByFile.get(path7) ?? [];
   }
   resolvesInFile(sourcePath, targetName) {
     if (!targetName) return true;
@@ -4810,7 +4792,7 @@ function moduleNameFromSourceLiteral(literal) {
 function moduleSpecFromSourceLiteral(literal) {
   return literal.replace(/^['"]|['"]$/g, "");
 }
-function extractFromMatches(matches, path5, allLines) {
+function extractFromMatches(matches, path7, allLines) {
   const symbols = [];
   const edges = [];
   for (const m of matches) {
@@ -4823,7 +4805,7 @@ function extractFromMatches(matches, path5, allLines) {
       const name2 = byName["symbol.function.name"]?.[0]?.text;
       if (name2) {
         symbols.push({
-          path: path5,
+          path: path7,
           name: name2,
           kind: "function",
           line: lineOf(def),
@@ -4836,7 +4818,7 @@ function extractFromMatches(matches, path5, allLines) {
       const name2 = byName["symbol.method.name"]?.[0]?.text;
       if (name2) {
         symbols.push({
-          path: path5,
+          path: path7,
           name: name2,
           kind: "method",
           line: lineOf(def),
@@ -4849,7 +4831,7 @@ function extractFromMatches(matches, path5, allLines) {
       const name2 = byName["symbol.class.name"]?.[0]?.text;
       if (name2) {
         symbols.push({
-          path: path5,
+          path: path7,
           name: name2,
           kind: "class",
           line: lineOf(def),
@@ -4858,7 +4840,7 @@ function extractFromMatches(matches, path5, allLines) {
         for (const parent of byName["edge.extends.parent"] ?? []) {
           edges.push({
             kind: "extends",
-            source_path: path5,
+            source_path: path7,
             source_name: name2,
             target: parent.text.toLowerCase(),
             line: lineOf(parent)
@@ -4871,7 +4853,7 @@ function extractFromMatches(matches, path5, allLines) {
       const name2 = byName["symbol.interface.name"]?.[0]?.text;
       if (name2) {
         symbols.push({
-          path: path5,
+          path: path7,
           name: name2,
           kind: "interface",
           line: lineOf(def),
@@ -4884,7 +4866,7 @@ function extractFromMatches(matches, path5, allLines) {
       const name2 = byName["symbol.type.name"]?.[0]?.text;
       if (name2) {
         symbols.push({
-          path: path5,
+          path: path7,
           name: name2,
           kind: "type",
           line: lineOf(def),
@@ -4897,7 +4879,7 @@ function extractFromMatches(matches, path5, allLines) {
       const name2 = byName["symbol.enum.name"]?.[0]?.text;
       if (name2) {
         symbols.push({
-          path: path5,
+          path: path7,
           name: name2,
           kind: "enum",
           line: lineOf(def),
@@ -4910,7 +4892,7 @@ function extractFromMatches(matches, path5, allLines) {
       const last = dotted.split(".").pop() ?? dotted;
       edges.push({
         kind: "imports",
-        source_path: path5,
+        source_path: path7,
         source_name: "",
         target: last.toLowerCase(),
         line: lineOf(targetNode)
@@ -4921,7 +4903,7 @@ function extractFromMatches(matches, path5, allLines) {
       if (modName) {
         edges.push({
           kind: "imports",
-          source_path: path5,
+          source_path: path7,
           source_name: "",
           target: modName.toLowerCase(),
           line: lineOf(sourceLit),
@@ -4933,7 +4915,7 @@ function extractFromMatches(matches, path5, allLines) {
       const sourceName = enclosingSymbolName(callTarget);
       edges.push({
         kind: "calls",
-        source_path: path5,
+        source_path: path7,
         source_name: sourceName,
         target: callTarget.text.toLowerCase(),
         line: lineOf(callTarget)
@@ -4945,7 +4927,7 @@ function extractFromMatches(matches, path5, allLines) {
       if (childName) {
         edges.push({
           kind: "extends",
-          source_path: path5,
+          source_path: path7,
           source_name: childName,
           target: parent.text.toLowerCase(),
           line: lineOf(parent)
@@ -4957,7 +4939,7 @@ function extractFromMatches(matches, path5, allLines) {
       if (childName) {
         edges.push({
           kind: "implements",
-          source_path: path5,
+          source_path: path7,
           source_name: childName,
           target: parent.text.toLowerCase(),
           line: lineOf(parent)
@@ -4967,7 +4949,7 @@ function extractFromMatches(matches, path5, allLines) {
   }
   return { symbols, edges };
 }
-function extractWithTreeSitter(handle4, lang, path5, content) {
+function extractWithTreeSitter(handle4, lang, path7, content) {
   const querySource = queryFor(lang);
   if (!querySource) return null;
   const tree = handle4.parse(lang, content);
@@ -4977,7 +4959,7 @@ function extractWithTreeSitter(handle4, lang, path5, content) {
     if (!query) return null;
     const matches = query.matches(tree.rootNode);
     const allLines = content.split("\n");
-    return extractFromMatches(matches, path5, allLines);
+    return extractFromMatches(matches, path7, allLines);
   } finally {
     try {
       tree.delete();
@@ -5176,10 +5158,10 @@ function langFromExt(ext) {
       return null;
   }
 }
-function languageForPath(path5) {
-  const dot = path5.lastIndexOf(".");
+function languageForPath(path7) {
+  const dot = path7.lastIndexOf(".");
   if (dot < 0) return null;
-  return langFromExt(path5.slice(dot));
+  return langFromExt(path7.slice(dot));
 }
 async function tryLoad(grammarDir) {
   if (handle2) return handle2;
@@ -5278,9 +5260,9 @@ async function ensureGrammar(h, lang) {
 
 // ../packages/orion-client-core/src/summaries.ts
 var SUMMARY_MAX_CHARS = 200;
-function familyFor(path5) {
-  const dot = path5.lastIndexOf(".");
-  const ext = dot >= 0 ? path5.slice(dot).toLowerCase() : "";
+function familyFor(path7) {
+  const dot = path7.lastIndexOf(".");
+  const ext = dot >= 0 ? path7.slice(dot).toLowerCase() : "";
   switch (ext) {
     case ".py":
       return "python";
@@ -5333,10 +5315,10 @@ function clean(text) {
 function stripDocstringQuotes(raw) {
   return raw.trim().replace(/^[rbRBuUfF]*("""|'''|"|')/, "").replace(/("""|'''|"|')$/, "");
 }
-function extractFileSummary(path5, content, opts) {
+function extractFileSummary(path7, content, opts) {
   if (!opts.shipDocstrings) return "";
   const lines = content.split("\n");
-  const raw = familyFor(path5) === "python" ? pythonModuleDocstring(lines) : leadingCommentBlock(lines, familyFor(path5));
+  const raw = familyFor(path7) === "python" ? pythonModuleDocstring(lines) : leadingCommentBlock(lines, familyFor(path7));
   return clean(raw);
 }
 function pythonModuleDocstring(lines) {
@@ -5391,10 +5373,10 @@ function leadingCommentBlock(lines, fam) {
   }
   return collected.filter((l) => l && !isLicenseNoise(l)).join(" ");
 }
-function extractSymbolSummaries(path5, content, symbols, opts) {
+function extractSymbolSummaries(path7, content, symbols, opts) {
   const out2 = /* @__PURE__ */ new Map();
   if (!opts.shipDocstrings || symbols.length === 0) return out2;
-  const fam = familyFor(path5);
+  const fam = familyFor(path7);
   const lines = content.split("\n");
   for (const s of symbols) {
     const raw = fam === "python" ? pythonSymbolDocstring(lines, s.line) : precedingCommentSummary(lines, s.line, fam);
@@ -6190,9 +6172,9 @@ var SWIFT_RULES = [
   { match: /^\s*extension\s+(\w+)/, kind: "type", nameGroup: 1 },
   { match: /^\s*(?:(?:public|private|internal|fileprivate|open|static|class|final|override|mutating)\s+)*func\s+(\w+)/, kind: "function", nameGroup: 1 }
 ];
-function languageFor(path5) {
-  const dot = path5.lastIndexOf(".");
-  const ext = dot >= 0 ? path5.slice(dot).toLowerCase() : "";
+function languageFor(path7) {
+  const dot = path7.lastIndexOf(".");
+  const ext = dot >= 0 ? path7.slice(dot).toLowerCase() : "";
   switch (ext) {
     case ".py":
       return { family: "python", rules: PYTHON_RULES };
@@ -6328,8 +6310,8 @@ function isProbablyGeneratedPath(p) {
   const lc = p.toLowerCase();
   return lc.includes("/generated/") || lc.includes("/__generated__/") || lc.includes("/build/") || lc.includes("/dist/") || lc.endsWith(".min.js") || lc.endsWith(".bundle.js");
 }
-function extractSymbols(path5, content) {
-  const { rules } = languageFor(path5);
+function extractSymbols(path7, content) {
+  const { rules } = languageFor(path7);
   if (rules.length === 0) return [];
   const out2 = [];
   const lines = content.split("\n");
@@ -6346,7 +6328,7 @@ function extractSymbols(path5, content) {
       if (!name2) continue;
       const sig = trimmed.length > 160 ? trimmed.slice(0, 160) + "\u2026" : trimmed;
       out2.push({
-        path: path5,
+        path: path7,
         name: name2,
         kind: rule.kind,
         line: i2 + 1,
@@ -6368,7 +6350,7 @@ function pathBasename(s) {
 function jsModuleTarget(spec) {
   return pathBasename(spec).replace(/\.(d\.)?ts$/, "").replace(/\.js$/, "");
 }
-function extractEdgesPython(path5, lines) {
+function extractEdgesPython(path7, lines) {
   const edges = [];
   const scope = [];
   const indentOf = (s) => {
@@ -6397,7 +6379,7 @@ function extractEdgesPython(path5, lines) {
         if (name2 && name2 !== "object") {
           edges.push({
             kind: "extends",
-            source_path: path5,
+            source_path: path7,
             source_name: child,
             target: name2.toLowerCase(),
             line: i2 + 1
@@ -6418,7 +6400,7 @@ function extractEdgesPython(path5, lines) {
       if (tgt) {
         edges.push({
           kind: "imports",
-          source_path: path5,
+          source_path: path7,
           source_name: "",
           target: tgt.toLowerCase(),
           line: i2 + 1
@@ -6434,7 +6416,7 @@ function extractEdgesPython(path5, lines) {
         if (tgt && tgt !== "*") {
           edges.push({
             kind: "imports",
-            source_path: path5,
+            source_path: path7,
             source_name: "",
             target: tgt.toLowerCase(),
             line: i2 + 1
@@ -6452,7 +6434,7 @@ function extractEdgesPython(path5, lines) {
         if (CALL_NOISE.has(target)) continue;
         edges.push({
           kind: "calls",
-          source_path: path5,
+          source_path: path7,
           source_name: source,
           target: target.toLowerCase(),
           line: i2 + 1
@@ -6462,7 +6444,7 @@ function extractEdgesPython(path5, lines) {
   }
   return edges;
 }
-function extractEdgesJsTs(path5, lines) {
+function extractEdgesJsTs(path7, lines) {
   const edges = [];
   const scope = [];
   let braceDepth = 0;
@@ -6481,7 +6463,7 @@ function extractEdgesJsTs(path5, lines) {
         if (tgt) {
           edges.push({
             kind: "imports",
-            source_path: path5,
+            source_path: path7,
             source_name: "",
             target: tgt.toLowerCase(),
             line: i2 + 1,
@@ -6497,7 +6479,7 @@ function extractEdgesJsTs(path5, lines) {
           if (cleaned) {
             edges.push({
               kind: "imports",
-              source_path: path5,
+              source_path: path7,
               source_name: "",
               target: cleaned.toLowerCase(),
               line: i2 + 1,
@@ -6515,7 +6497,7 @@ function extractEdgesJsTs(path5, lines) {
       if (parent) {
         edges.push({
           kind: "extends",
-          source_path: path5,
+          source_path: path7,
           source_name: child,
           target: parent.toLowerCase(),
           line: i2 + 1
@@ -6527,7 +6509,7 @@ function extractEdgesJsTs(path5, lines) {
           if (cleaned) {
             edges.push({
               kind: "implements",
-              source_path: path5,
+              source_path: path7,
               source_name: child,
               target: cleaned.toLowerCase(),
               line: i2 + 1
@@ -6550,7 +6532,7 @@ function extractEdgesJsTs(path5, lines) {
         if (CALL_NOISE.has(target)) continue;
         edges.push({
           kind: "calls",
-          source_path: path5,
+          source_path: path7,
           source_name: source,
           target: target.toLowerCase(),
           line: i2 + 1
@@ -6564,7 +6546,7 @@ function extractEdgesJsTs(path5, lines) {
   }
   return edges;
 }
-function extractEdgesGo(path5, lines) {
+function extractEdgesGo(path7, lines) {
   const edges = [];
   let inImportBlock = false;
   for (let i2 = 0; i2 < lines.length; i2++) {
@@ -6583,7 +6565,7 @@ function extractEdgesGo(path5, lines) {
         const tgt = lastWord(m[1].replace(/\//g, "."));
         edges.push({
           kind: "imports",
-          source_path: path5,
+          source_path: path7,
           source_name: "",
           target: tgt.toLowerCase(),
           line: i2 + 1
@@ -6596,7 +6578,7 @@ function extractEdgesGo(path5, lines) {
       const tgt = lastWord(im[1].replace(/\//g, "."));
       edges.push({
         kind: "imports",
-        source_path: path5,
+        source_path: path7,
         source_name: "",
         target: tgt.toLowerCase(),
         line: i2 + 1
@@ -6605,7 +6587,7 @@ function extractEdgesGo(path5, lines) {
   }
   return edges;
 }
-function extractEdgesRust(path5, lines) {
+function extractEdgesRust(path7, lines) {
   const edges = [];
   for (let i2 = 0; i2 < lines.length; i2++) {
     const line = lines[i2];
@@ -6616,7 +6598,7 @@ function extractEdgesRust(path5, lines) {
       if (tgt) {
         edges.push({
           kind: "imports",
-          source_path: path5,
+          source_path: path7,
           source_name: "",
           target: tgt.toLowerCase(),
           line: i2 + 1
@@ -6629,7 +6611,7 @@ function extractEdgesRust(path5, lines) {
           if (cleaned && cleaned !== "*" && cleaned !== "self") {
             edges.push({
               kind: "imports",
-              source_path: path5,
+              source_path: path7,
               source_name: "",
               target: cleaned.toLowerCase(),
               line: i2 + 1
@@ -6642,7 +6624,7 @@ function extractEdgesRust(path5, lines) {
     if (implMatch) {
       edges.push({
         kind: "implements",
-        source_path: path5,
+        source_path: path7,
         source_name: implMatch[2],
         target: implMatch[1].toLowerCase(),
         line: i2 + 1
@@ -6651,7 +6633,7 @@ function extractEdgesRust(path5, lines) {
   }
   return edges;
 }
-function extractEdgesJava(path5, lines) {
+function extractEdgesJava(path7, lines) {
   const edges = [];
   for (let i2 = 0; i2 < lines.length; i2++) {
     const line = lines[i2];
@@ -6660,7 +6642,7 @@ function extractEdgesJava(path5, lines) {
       const tgt = lastWord(importMatch[1]);
       edges.push({
         kind: "imports",
-        source_path: path5,
+        source_path: path7,
         source_name: "",
         target: tgt.toLowerCase(),
         line: i2 + 1
@@ -6672,7 +6654,7 @@ function extractEdgesJava(path5, lines) {
       if (classMatch[2]) {
         edges.push({
           kind: "extends",
-          source_path: path5,
+          source_path: path7,
           source_name: child,
           target: classMatch[2].toLowerCase(),
           line: i2 + 1
@@ -6684,7 +6666,7 @@ function extractEdgesJava(path5, lines) {
           if (cleaned) {
             edges.push({
               kind: "implements",
-              source_path: path5,
+              source_path: path7,
               source_name: child,
               target: cleaned.toLowerCase(),
               line: i2 + 1
@@ -6696,7 +6678,7 @@ function extractEdgesJava(path5, lines) {
   }
   return edges;
 }
-function extractEdgesRuby(path5, lines) {
+function extractEdgesRuby(path7, lines) {
   const edges = [];
   for (let i2 = 0; i2 < lines.length; i2++) {
     const line = lines[i2];
@@ -6705,7 +6687,7 @@ function extractEdgesRuby(path5, lines) {
       const tgt = pathBasename(requireMatch[1]).replace(/\.rb$/, "");
       edges.push({
         kind: "imports",
-        source_path: path5,
+        source_path: path7,
         source_name: "",
         target: tgt.toLowerCase(),
         line: i2 + 1
@@ -6715,7 +6697,7 @@ function extractEdgesRuby(path5, lines) {
     if (classMatch) {
       edges.push({
         kind: "extends",
-        source_path: path5,
+        source_path: path7,
         source_name: classMatch[1],
         target: classMatch[2].toLowerCase(),
         line: i2 + 1
@@ -6743,7 +6725,7 @@ function declRegexFor(keywords) {
   }
   return re;
 }
-function extractEdgesColonInherit(path5, lines, opts) {
+function extractEdgesColonInherit(path7, lines, opts) {
   const edges = [];
   const declRe = declRegexFor(opts.declKeywords);
   for (let i2 = 0; i2 < lines.length; i2++) {
@@ -6754,7 +6736,7 @@ function extractEdgesColonInherit(path5, lines, opts) {
       if (target) {
         edges.push({
           kind: "imports",
-          source_path: path5,
+          source_path: path7,
           source_name: "",
           target: target.toLowerCase(),
           line: i2 + 1
@@ -6775,7 +6757,7 @@ function extractEdgesColonInherit(path5, lines, opts) {
         if (/^\w+$/.test(name2) && name2 !== child) {
           edges.push({
             kind: "extends",
-            source_path: path5,
+            source_path: path7,
             source_name: child,
             target: name2.toLowerCase(),
             line: i2 + 1
@@ -6786,7 +6768,7 @@ function extractEdgesColonInherit(path5, lines, opts) {
   }
   return edges;
 }
-function extractEdgesPhp(path5, lines) {
+function extractEdgesPhp(path7, lines) {
   const edges = [];
   for (let i2 = 0; i2 < lines.length; i2++) {
     const line = lines[i2];
@@ -6794,7 +6776,7 @@ function extractEdgesPhp(path5, lines) {
     if (use) {
       edges.push({
         kind: "imports",
-        source_path: path5,
+        source_path: path7,
         source_name: "",
         target: lastWord(use[1].replace(/\\/g, ".")).toLowerCase(),
         line: i2 + 1
@@ -6804,7 +6786,7 @@ function extractEdgesPhp(path5, lines) {
     if (req) {
       edges.push({
         kind: "imports",
-        source_path: path5,
+        source_path: path7,
         source_name: "",
         target: pathBasename(req[1]).toLowerCase(),
         line: i2 + 1
@@ -6816,7 +6798,7 @@ function extractEdgesPhp(path5, lines) {
       if (decl[2]) {
         edges.push({
           kind: "extends",
-          source_path: path5,
+          source_path: path7,
           source_name: child,
           target: lastWord(decl[2].replace(/\\/g, ".")).toLowerCase(),
           line: i2 + 1
@@ -6828,7 +6810,7 @@ function extractEdgesPhp(path5, lines) {
           if (name2) {
             edges.push({
               kind: "implements",
-              source_path: path5,
+              source_path: path7,
               source_name: child,
               target: name2.toLowerCase(),
               line: i2 + 1
@@ -6840,24 +6822,24 @@ function extractEdgesPhp(path5, lines) {
   }
   return edges;
 }
-function extractEdges(path5, content) {
-  const { family } = languageFor(path5);
+function extractEdges(path7, content) {
+  const { family } = languageFor(path7);
   const lines = content.split("\n");
   switch (family) {
     case "python":
-      return extractEdgesPython(path5, lines);
+      return extractEdgesPython(path7, lines);
     case "jsts":
-      return extractEdgesJsTs(path5, lines);
+      return extractEdgesJsTs(path7, lines);
     case "go":
-      return extractEdgesGo(path5, lines);
+      return extractEdgesGo(path7, lines);
     case "rust":
-      return extractEdgesRust(path5, lines);
+      return extractEdgesRust(path7, lines);
     case "java":
-      return extractEdgesJava(path5, lines);
+      return extractEdgesJava(path7, lines);
     case "ruby":
-      return extractEdgesRuby(path5, lines);
+      return extractEdgesRuby(path7, lines);
     case "cfamily":
-      return extractEdgesColonInherit(path5, lines, {
+      return extractEdgesColonInherit(path7, lines, {
         importRe: /^\s*#\s*include\s+"([^"]+)"/,
         importTarget: pathBasename,
         // C++ `enum class Foo : int` names a storage type, not a base — excluded (see declKeywords).
@@ -6865,21 +6847,21 @@ function extractEdges(path5, content) {
         baseNoise: /\b(?:public|private|protected|virtual)\b/g
       });
     case "csharp":
-      return extractEdgesColonInherit(path5, lines, {
+      return extractEdgesColonInherit(path7, lines, {
         importRe: /^\s*(?:global\s+)?using\s+(?:static\s+)?([\w.]+)\s*;/,
         importTarget: lastWord,
         // `enum Color : byte` is a storage type, not a base — excluded (see declKeywords).
         declKeywords: ["class", "struct", "interface"]
       });
     case "swift":
-      return extractEdgesColonInherit(path5, lines, {
+      return extractEdgesColonInherit(path7, lines, {
         importRe: /^\s*import\s+([\w.]+)/,
         importTarget: lastWord,
         // Swift DOES carry real conformance on an enum, and its query emits those edges.
         declKeywords: ["class", "struct", "enum", "protocol"]
       });
     case "php":
-      return extractEdgesPhp(path5, lines);
+      return extractEdgesPhp(path7, lines);
     default:
       return [];
   }
@@ -7116,16 +7098,16 @@ var WorkspaceIndexer = class {
     this.cachedRemovals.delete(r.relPath);
     this.cachedUpdates.set(r.relPath, r);
   }
-  rememberRemoval(path5) {
+  rememberRemoval(path7) {
     if (!this.building) return;
-    this.cachedUpdates.delete(path5);
-    this.cachedRemovals.add(path5);
+    this.cachedUpdates.delete(path7);
+    this.cachedRemovals.add(path7);
   }
-  shouldSkipStaleBuildResult(path5) {
-    if (this.cachedUpdates.has(path5)) return true;
+  shouldSkipStaleBuildResult(path7) {
+    if (this.cachedUpdates.has(path7)) return true;
     for (const removed of this.cachedRemovals) {
       const prefix = removed.endsWith("/") ? removed : removed + "/";
-      if (path5 === removed || path5.startsWith(prefix)) return true;
+      if (path7 === removed || path7.startsWith(prefix)) return true;
     }
     return false;
   }
@@ -7831,18 +7813,18 @@ var WorkspaceIndexer = class {
       chunks: buildChunksForFile(file.relPath, text, file.symbols, file.fileSummary)
     };
   }
-  async tryTreeSitter(path5, content, sizeBytes) {
+  async tryTreeSitter(path7, content, sizeBytes) {
     const enabled = this.indexConfig.useTreeSitter();
     const maxBytes = this.indexConfig.treeSitterMaxFileBytes();
     if (!shouldExtractWithTreeSitter(sizeBytes, { enabled, maxBytes })) {
       return null;
     }
-    const lang = languageForPath(path5);
+    const lang = languageForPath(path7);
     if (!lang) return null;
     const pool = this.getWorkerPool();
     if (pool) {
       try {
-        return await pool.extract(lang, path5, content);
+        return await pool.extract(lang, path7, content);
       } catch (e) {
         console.warn("orion: tree-sitter worker failed, falling back inline", e);
       }
@@ -7852,7 +7834,7 @@ var WorkspaceIndexer = class {
       if (!handle4) return null;
       const ready = await ensureGrammar(handle4, lang);
       if (!ready) return null;
-      return extractWithTreeSitter(handle4, lang, path5, content);
+      return extractWithTreeSitter(handle4, lang, path7, content);
     } catch (e) {
       console.warn("orion: tree-sitter extraction failed, using regex fallback", e);
       return null;
@@ -7927,9 +7909,9 @@ function changedLineRanges(before, after) {
   }
   return ranges;
 }
-function changedSymbolNames(path5, before, after) {
-  const postSyms = extractSymbols(path5, after);
-  const preSyms = extractSymbols(path5, before);
+function changedSymbolNames(path7, before, after) {
+  const postSyms = extractSymbols(path7, after);
+  const preSyms = extractSymbols(path7, before);
   const ranges = changedLineRanges(before, after);
   const inChangedRange = (line) => ranges.some(([s, e]) => s <= line && line <= e);
   const names = /* @__PURE__ */ new Set();
@@ -7942,22 +7924,22 @@ function changedSymbolNames(path5, before, after) {
   }
   return names;
 }
-function moduleStem(path5) {
-  const base = path5.split("/").pop() ?? "";
+function moduleStem(path7) {
+  const base = path7.split("/").pop() ?? "";
   const dot = base.lastIndexOf(".");
   return dot > 0 ? base.slice(0, dot) : base;
 }
-function buildDependencyAdvisory(path5, before, after, graph, options = {}) {
-  if (!path5 || after === null) return null;
+function buildDependencyAdvisory(path7, before, after, graph, options = {}) {
+  if (!path7 || after === null) return null;
   if (!graph.status().ready) return null;
   const maxFiles = Math.max(1, options.maxFiles ?? DEPENDENCY_ADVISORY_MAX_FILES);
   const maxSymbols = Math.max(1, options.maxSymbols ?? DEPENDENCY_ADVISORY_MAX_SYMBOLS);
   const isNew = before === null;
   let changed;
   if (isNew) {
-    changed = new Set(extractSymbols(path5, after).map((s) => s.name).filter(Boolean));
+    changed = new Set(extractSymbols(path7, after).map((s) => s.name).filter(Boolean));
   } else {
-    changed = changedSymbolNames(path5, before, after);
+    changed = changedSymbolNames(path7, before, after);
     if (changed.size === 0) return null;
   }
   const affected = /* @__PURE__ */ new Map();
@@ -7972,7 +7954,7 @@ function buildDependencyAdvisory(path5, before, after, graph, options = {}) {
     return names.has(name2.toLowerCase());
   };
   const add = (sourcePath, name2) => {
-    if (!sourcePath || sourcePath === path5) return;
+    if (!sourcePath || sourcePath === path7) return;
     if (definesLocally(sourcePath, name2)) return;
     let names = affected.get(sourcePath);
     if (!names) affected.set(sourcePath, names = /* @__PURE__ */ new Set());
@@ -7986,7 +7968,7 @@ function buildDependencyAdvisory(path5, before, after, graph, options = {}) {
       add(edge.source_path, name2);
     }
   }
-  const stem = moduleStem(path5);
+  const stem = moduleStem(path7);
   if (stem) {
     for (const edge of graph.findImporters(stem, { strictReachable: true })) {
       add(edge.source_path, stem);
@@ -7999,15 +7981,702 @@ function buildDependencyAdvisory(path5, before, after, graph, options = {}) {
   const symbolNames = [...changed].sort();
   let symStr = symbolNames.slice(0, maxSymbols).join(", ");
   if (symbolNames.length > maxSymbols) symStr += ", \u2026";
-  const lead = isNew ? `${files.length} existing file(s) already import or reference ${path5}` : `${files.length} other file(s) import or use what you changed in ${path5} (${symStr})`;
+  const lead = isNew ? `${files.length} existing file(s) already import or reference ${path7}` : `${files.length} other file(s) import or use what you changed in ${path7} (${symStr})`;
   let note = `${lead}. Affected (best-effort, by name \u2014 verify before relying): ${shown.join(", ")}`;
   if (extra > 0) {
-    note += `. +${extra} more \u2014 use trace_codebase on ${path5} for the full set`;
+    note += `. +${extra} more \u2014 use trace_codebase on ${path7} for the full set`;
   }
   note += ".";
   return { files, note };
 }
 
+// ../packages/orion-client-core/src/vectorStore.ts
+var path5 = __toESM(require("path"));
+var import_crypto2 = require("crypto");
+var import_fs3 = require("fs");
+var VECTOR_STORE_VERSION = 1;
+var VECTOR_CHECKPOINT_ROWS = 1024;
+var VECTOR_SCAN_BLOCK_ROWS = 1024;
+var VECTOR_LOCK_STALE_MS = 15 * 6e4;
+var VECTOR_LAYER_BUSY_PREFIX = "vector layer busy:";
+var BYTES_PER_FLOAT = 4;
+var VectorLayerBusyError = class extends Error {
+  constructor(lockPath, holderPid) {
+    super(`${VECTOR_LAYER_BUSY_PREFIX} another Orion process (pid ${holderPid}) is embedding this workspace`);
+    this.lockPath = lockPath;
+    this.holderPid = holderPid;
+    this.name = "VectorLayerBusyError";
+  }
+};
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var realFs2 = {
+  readText: (p) => import_fs3.promises.readFile(p, "utf8"),
+  writeTextAtomic: (p, content) => atomicWriteFile(p, content),
+  writeBytesAtomic: (p, bytes) => atomicWriteFile(p, Buffer.from(bytes)),
+  appendBytes: (p, bytes) => import_fs3.promises.appendFile(p, bytes),
+  readBytesAt: async (p, offset, length) => {
+    const handle4 = await import_fs3.promises.open(p, "r");
+    try {
+      const buffer = new Uint8Array(length);
+      let read = 0;
+      while (read < length) {
+        const { bytesRead } = await handle4.read(buffer, read, length - read, offset + read);
+        if (bytesRead === 0) break;
+        read += bytesRead;
+      }
+      return read === length ? buffer : buffer.subarray(0, read);
+    } finally {
+      await handle4.close();
+    }
+  },
+  fileSize: async (p) => {
+    try {
+      return (await import_fs3.promises.stat(p)).size;
+    } catch {
+      return null;
+    }
+  },
+  truncate: (p, size) => import_fs3.promises.truncate(p, size),
+  rename: (from, to) => import_fs3.promises.rename(from, to),
+  mkdir: async (p) => {
+    await import_fs3.promises.mkdir(p, { recursive: true });
+  },
+  rm: (p) => import_fs3.promises.rm(p, { force: true }),
+  createExclusive: async (p, content) => {
+    try {
+      await import_fs3.promises.writeFile(p, content, { flag: "wx" });
+      return true;
+    } catch (error) {
+      if (error.code === "EEXIST") return false;
+      throw error;
+    }
+  }
+};
+function vectorContentHash(text) {
+  return (0, import_crypto2.createHash)("sha256").update(text, "utf8").digest("hex").slice(0, 32);
+}
+function vectorModelSlug(model) {
+  const slug = model.toLowerCase().replace(/[^a-z0-9.]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "model";
+}
+function encodeManifest(root, model, manifest) {
+  const rows = manifest.rows.map((r) => [r.hash, r.path, r.startLine, r.endLine, r.sig]);
+  return JSON.stringify({ v: VECTOR_STORE_VERSION, root, model, dims: manifest.dims, rows });
+}
+function decodeManifest(raw, expected) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const m = parsed;
+  if (m.v !== VECTOR_STORE_VERSION || m.root !== expected.root || m.model !== expected.model) return null;
+  const dims = m.dims;
+  if (typeof dims !== "number" || !Number.isInteger(dims) || dims <= 0) return null;
+  if (!Array.isArray(m.rows)) return null;
+  const rows = [];
+  for (const entry of m.rows) {
+    if (!Array.isArray(entry) || entry.length !== 5) return null;
+    const [hash, p, startLine, endLine, sig] = entry;
+    if (typeof hash !== "string" || typeof p !== "string" || typeof sig !== "string") return null;
+    if (typeof startLine !== "number" || typeof endLine !== "number") return null;
+    rows.push({ hash, path: p, startLine, endLine, sig });
+  }
+  return { dims, rows };
+}
+var VectorStore = class {
+  root;
+  model;
+  fsOps;
+  log;
+  now;
+  pidAlive;
+  dir;
+  slug;
+  dimsValue = 0;
+  rowsValue = [];
+  /** Rows the manifest on disk describes; rows past this are appended but uncommitted. */
+  committedRows = 0;
+  loaded = false;
+  lockHeld = false;
+  constructor(options) {
+    this.root = options.root;
+    this.model = options.model;
+    this.fsOps = options.fsOps ?? realFs2;
+    this.log = options.log ?? (() => void 0);
+    this.now = options.now ?? Date.now;
+    this.pidAlive = options.pidAlive ?? processAlive;
+    this.dir = path5.join(options.baseDir ?? defaultIndexCacheBaseDir(), indexCacheFingerprint(options.root));
+    this.slug = vectorModelSlug(options.model);
+  }
+  binPath() {
+    return path5.join(this.dir, `vectors.${this.slug}.bin`);
+  }
+  manifestPath() {
+    return path5.join(this.dir, `vectors.${this.slug}.json`);
+  }
+  lockPath() {
+    return path5.join(this.dir, `vectors.${this.slug}.lock`);
+  }
+  /** Take the layer's writer lock: create the lock file exclusively; break a
+   *  stale one (dead holder, or older than VECTOR_LOCK_STALE_MS) once and retry;
+   *  throw VectorLayerBusyError for a live holder. */
+  async acquireLock() {
+    await this.fsOps.mkdir(this.dir);
+    const record = { pid: process.pid, startedAt: this.now() };
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (await this.fsOps.createExclusive(this.lockPath(), JSON.stringify(record))) {
+        this.lockHeld = true;
+        return;
+      }
+      const holder = await this.readLock();
+      const stale = holder === null || holder.pid === process.pid || !this.pidAlive(holder.pid) || this.now() - holder.startedAt > VECTOR_LOCK_STALE_MS;
+      if (!stale) throw new VectorLayerBusyError(this.lockPath(), holder.pid);
+      this.log(`orion: vector layer for ${this.model} \u2014 breaking a stale lock (pid ${holder?.pid ?? "?"})`);
+      await this.fsOps.rm(this.lockPath());
+    }
+    throw new VectorLayerBusyError(this.lockPath(), 0);
+  }
+  async readLock() {
+    try {
+      const parsed = JSON.parse(await this.fsOps.readText(this.lockPath()));
+      if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "number") return null;
+      return { pid: parsed.pid, startedAt: parsed.startedAt };
+    } catch {
+      return null;
+    }
+  }
+  /** Release the writer lock. Safe to call more than once, and without `load()`. */
+  async close() {
+    if (!this.lockHeld) return;
+    this.lockHeld = false;
+    await this.fsOps.rm(this.lockPath());
+  }
+  dims() {
+    return this.dimsValue;
+  }
+  size() {
+    return this.rowsValue.length;
+  }
+  rows() {
+    return this.rowsValue;
+  }
+  /** Take the lock, then read the manifest and reconcile it with the .bin: an
+   *  absent layer starts empty; a rejected manifest or a .bin shorter than its
+   *  manifest discards the layer (a wrong vector is structurally impossible —
+   *  the worst case is re-embedding once); a .bin longer than its manifest is a
+   *  crashed append and its tail is truncated. */
+  async load() {
+    await this.acquireLock();
+    try {
+      await this.reconcile();
+    } catch (error) {
+      await this.close();
+      throw error;
+    }
+  }
+  /** The manifest ↔ .bin reconcile `load()` runs under the lock. */
+  async reconcile() {
+    this.loaded = true;
+    this.rowsValue = [];
+    this.dimsValue = 0;
+    this.committedRows = 0;
+    let raw;
+    try {
+      raw = await this.fsOps.readText(this.manifestPath());
+    } catch {
+      return;
+    }
+    const manifest = decodeManifest(raw, { root: this.root, model: this.model });
+    if (!manifest) {
+      this.log(`orion: vector layer for ${this.model} rejected (version/identity/shape) \u2014 re-embedding`);
+      await this.discard();
+      return;
+    }
+    const binSize = await this.fsOps.fileSize(this.binPath());
+    const committedBytes = manifest.rows.length * manifest.dims * BYTES_PER_FLOAT;
+    if (binSize === null || binSize < committedBytes) {
+      this.log(`orion: vector file for ${this.model} is shorter than its manifest \u2014 re-embedding`);
+      await this.discard();
+      return;
+    }
+    if (binSize > committedBytes) {
+      await this.fsOps.truncate(this.binPath(), committedBytes);
+      this.log(`orion: vector layer for ${this.model} dropped an uncommitted tail (${binSize - committedBytes} bytes)`);
+    }
+    this.dimsValue = manifest.dims;
+    this.rowsValue = manifest.rows;
+    this.committedRows = manifest.rows.length;
+  }
+  async discard() {
+    await this.fsOps.rm(this.binPath());
+    await this.fsOps.rm(this.manifestPath());
+    this.rowsValue = [];
+    this.dimsValue = 0;
+    this.committedRows = 0;
+  }
+  /** Append rows with their vectors (same length, every vector `dims` wide —
+   *  the first append of an empty layer fixes `dims`). Rows land in the .bin at
+   *  once; the manifest checkpoints every VECTOR_CHECKPOINT_ROWS rows and on
+   *  `flush()`, so a run's progress survives a crash in bounded pieces. */
+  async append(rows, vectors) {
+    this.assertLoaded();
+    if (rows.length !== vectors.length) throw new Error("vector store: rows and vectors differ in length");
+    if (rows.length === 0) return;
+    const dims = vectors[0].length;
+    if (dims === 0) throw new Error("vector store: an empty vector");
+    if (this.dimsValue === 0) {
+      this.dimsValue = dims;
+      await this.fsOps.mkdir(this.dir);
+      await this.fsOps.writeBytesAtomic(this.binPath(), new Uint8Array(0));
+    } else if (dims !== this.dimsValue) {
+      throw new Error(`vector store: width ${dims} does not match the layer's ${this.dimsValue}`);
+    }
+    const block = new Float32Array(rows.length * dims);
+    for (let i2 = 0; i2 < vectors.length; i2++) {
+      if (vectors[i2].length !== dims) throw new Error("vector store: vectors of differing width");
+      block.set(vectors[i2], i2 * dims);
+    }
+    await this.fsOps.appendBytes(this.binPath(), new Uint8Array(block.buffer, block.byteOffset, block.byteLength));
+    for (const row of rows) this.rowsValue.push(row);
+    if (this.rowsValue.length - this.committedRows >= VECTOR_CHECKPOINT_ROWS) await this.flush();
+  }
+  /** Commit every appended row to the manifest (a no-op when nothing is pending). */
+  async flush() {
+    this.assertLoaded();
+    if (this.rowsValue.length === this.committedRows) return;
+    await this.fsOps.mkdir(this.dir);
+    await this.fsOps.writeTextAtomic(
+      this.manifestPath(),
+      encodeManifest(this.root, this.model, { dims: this.dimsValue, rows: this.rowsValue })
+    );
+    this.committedRows = this.rowsValue.length;
+  }
+  /** Stream every row's vector, in row order, through a reusable block buffer:
+   *  `visit` must not retain `vector` past the call. `include` skips rows
+   *  without reading them into the visit (dead rows still cost the block read). */
+  async scan(visit, include) {
+    this.assertLoaded();
+    const total = this.rowsValue.length;
+    if (total === 0) return;
+    const dims = this.dimsValue;
+    const rowBytes = dims * BYTES_PER_FLOAT;
+    for (let start2 = 0; start2 < total; start2 += VECTOR_SCAN_BLOCK_ROWS) {
+      const count = Math.min(VECTOR_SCAN_BLOCK_ROWS, total - start2);
+      const bytes = await this.fsOps.readBytesAt(this.binPath(), start2 * rowBytes, count * rowBytes);
+      if (bytes.length < count * rowBytes) {
+        throw new Error("vector store: the vector file is shorter than its manifest");
+      }
+      const floats = new Float32Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + count * rowBytes));
+      for (let i2 = 0; i2 < count; i2++) {
+        const rowIndex = start2 + i2;
+        if (include && !include(rowIndex)) continue;
+        visit(rowIndex, floats.subarray(i2 * dims, (i2 + 1) * dims));
+      }
+    }
+  }
+  /** Rewrite the layer with only the rows `keep` selects — the dead-row sweep
+   *  after a reconcile. Streams the old .bin block by block into a sibling file
+   *  and renames it over, then commits the surviving rows' manifest. */
+  async compact(keep) {
+    this.assertLoaded();
+    const total = this.rowsValue.length;
+    const survivors = [];
+    if (total === 0) return { kept: 0, dropped: 0 };
+    const dims = this.dimsValue;
+    const rowBytes = dims * BYTES_PER_FLOAT;
+    const tmp = `${this.binPath()}.compact`;
+    await this.fsOps.writeBytesAtomic(tmp, new Uint8Array(0));
+    for (let start2 = 0; start2 < total; start2 += VECTOR_SCAN_BLOCK_ROWS) {
+      const count = Math.min(VECTOR_SCAN_BLOCK_ROWS, total - start2);
+      const bytes = await this.fsOps.readBytesAt(this.binPath(), start2 * rowBytes, count * rowBytes);
+      const keptBytes = [];
+      for (let i2 = 0; i2 < count; i2++) {
+        const rowIndex = start2 + i2;
+        const row = this.rowsValue[rowIndex];
+        if (!keep(row, rowIndex)) continue;
+        survivors.push(row);
+        keptBytes.push(bytes.subarray(i2 * rowBytes, (i2 + 1) * rowBytes));
+      }
+      if (keptBytes.length > 0) {
+        const merged = new Uint8Array(keptBytes.length * rowBytes);
+        keptBytes.forEach((chunk, i2) => merged.set(chunk, i2 * rowBytes));
+        await this.fsOps.appendBytes(tmp, merged);
+      }
+    }
+    await this.fsOps.rename(tmp, this.binPath());
+    const dropped = total - survivors.length;
+    this.rowsValue = survivors;
+    this.committedRows = -1;
+    await this.fsOps.writeTextAtomic(
+      this.manifestPath(),
+      encodeManifest(this.root, this.model, { dims, rows: survivors })
+    );
+    this.committedRows = survivors.length;
+    return { kept: survivors.length, dropped };
+  }
+  assertLoaded() {
+    if (!this.loaded) throw new Error("vector store: load() first");
+  }
+};
+
+// ../packages/orion-client-core/src/enhancedRetrieval.ts
+var ENHANCED_TEST_DIRS = /* @__PURE__ */ new Set(["test", "tests", "testing"]);
+var ENHANCED_CHUNK_SOURCE_CHARS = 1e4;
+var ENHANCED_EMBED_BATCH_SIZE = 16;
+var ENHANCED_EMBED_MAX_RETRIES = 2;
+var ENHANCED_PAYLOAD_BUDGET_BYTES = 8 * 1024 * 1024;
+var COMPACT_MIN_DEAD_ROWS = 1e3;
+var COMPACT_DEAD_RATIO = 0.25;
+var CODE_CHUNK_KINDS = /* @__PURE__ */ new Set(["function", "method", "class", "module", "window"]);
+var CLASS_LIKE_SYMBOL_KINDS = /* @__PURE__ */ new Set(["class", "interface", "struct", "trait", "enum"]);
+function retrievalChunkType(kind) {
+  if (kind === "function" || kind === "method") return "function";
+  if (kind === "class") return "class";
+  return "file";
+}
+function isTestDirectoryPath(relPath) {
+  const parts2 = relPath.replace(/\\/g, "/").split("/");
+  return parts2.slice(0, -1).some((part) => ENHANCED_TEST_DIRS.has(part.toLowerCase()));
+}
+function chunkSource(lines, startLine, endLine) {
+  return lines.slice(Math.max(0, startLine - 1), Math.max(0, endLine)).join("\n");
+}
+function embeddingText(relPath, type, source) {
+  return `File Path: ${relPath}
+File Type: ${type}
+
+${source.slice(0, ENHANCED_CHUNK_SOURCE_CHARS)}`;
+}
+function fileSignature(stat) {
+  return `${stat.size}:${stat.mtimeMs}`;
+}
+function chunkIdentity(chunk, symbols) {
+  let name2 = chunk.title;
+  let parent = null;
+  if (chunk.kind === "function" || chunk.kind === "method" || chunk.kind === "class") {
+    const own = symbols.find((s) => s.line === chunk.startLine);
+    if (own) name2 = own.name;
+    if (chunk.kind === "method") {
+      for (const s of symbols) {
+        if (s.line >= chunk.startLine) break;
+        if (CLASS_LIKE_SYMBOL_KINDS.has(s.kind)) parent = s.name;
+      }
+    }
+  }
+  return { name: name2, parent };
+}
+function normalizeInPlace(vector) {
+  let sum = 0;
+  for (let i2 = 0; i2 < vector.length; i2++) sum += vector[i2] * vector[i2];
+  const norm = Math.sqrt(sum);
+  if (norm > 0) for (let i2 = 0; i2 < vector.length; i2++) vector[i2] /= norm;
+  return vector;
+}
+function cosineAgainstNormalized(query, row) {
+  let dot = 0;
+  let sum = 0;
+  for (let i2 = 0; i2 < query.length; i2++) {
+    dot += query[i2] * row[i2];
+    sum += row[i2] * row[i2];
+  }
+  const norm = Math.sqrt(sum);
+  return norm > 0 ? dot / norm : 0;
+}
+var TopK = class {
+  constructor(k) {
+    this.k = k;
+  }
+  rows = [];
+  scores = [];
+  offer(rowIndex, score) {
+    if (this.k <= 0) return;
+    const full = this.rows.length >= this.k;
+    if (full && score <= this.scores[this.scores.length - 1]) return;
+    let lo = 0;
+    let hi = this.scores.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (this.scores[mid] >= score) lo = mid + 1;
+      else hi = mid;
+    }
+    this.rows.splice(lo, 0, rowIndex);
+    this.scores.splice(lo, 0, score);
+    if (full) {
+      this.rows.pop();
+      this.scores.pop();
+    }
+  }
+  entries() {
+    return this.rows.map((rowIndex, i2) => ({ rowIndex, score: this.scores[i2] }));
+  }
+};
+var inFlight = /* @__PURE__ */ new Map();
+async function serialized(key, run2) {
+  const prior = inFlight.get(key) ?? Promise.resolve();
+  const next = prior.catch(() => void 0).then(run2);
+  inFlight.set(key, next);
+  try {
+    return await next;
+  } finally {
+    if (inFlight.get(key) === next) inFlight.delete(key);
+  }
+}
+var defaultSleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+async function enhancedRetrieve(request, deps) {
+  return await serialized(`${deps.baseDir ?? ""}\0${deps.root}`, () => runEnhancedRetrieve(request, deps));
+}
+async function runEnhancedRetrieve(request, deps) {
+  const now = deps.now ?? Date.now;
+  const started = now();
+  const log = deps.log ?? (() => void 0);
+  const sleep = deps.sleep ?? defaultSleep;
+  const batchSize = Math.max(1, deps.batchSize ?? ENHANCED_EMBED_BATCH_SIZE);
+  const maxRetries = Math.max(1, deps.maxRetries ?? ENHANCED_EMBED_MAX_RETRIES);
+  const payloadBudget = deps.payloadBudgetBytes ?? ENHANCED_PAYLOAD_BUDGET_BYTES;
+  const scope = normalizeScope(request.scope);
+  const inventory = [];
+  for (const chunk of deps.chunks()) {
+    if (!CODE_CHUNK_KINDS.has(chunk.kind)) continue;
+    if (isTestDirectoryPath(chunk.path)) continue;
+    if (scope && !inScope(chunk.path, scope)) continue;
+    inventory.push({ chunk, type: retrievalChunkType(chunk.kind), rowIndex: -1 });
+  }
+  const byPath = /* @__PURE__ */ new Map();
+  for (const entry of inventory) {
+    const list = byPath.get(entry.chunk.path);
+    if (list) list.push(entry);
+    else byPath.set(entry.chunk.path, [entry]);
+  }
+  const queryResponse = await deps.embeddings.embed({
+    texts: [request.queryText],
+    inputType: "query",
+    sessionId: request.sessionId
+  });
+  const model = queryResponse.model;
+  const provider = queryResponse.provider;
+  const query = normalizeInPlace(Float32Array.from(queryResponse.vectors[0] ?? []));
+  const stats = {
+    files_considered: byPath.size,
+    chunks_considered: inventory.length,
+    chunks_embedded: 0,
+    cache_hits: 0,
+    failed_chunks: 0,
+    files_sent: 0,
+    files_truncated: 0,
+    elapsed_ms: 0
+  };
+  const store2 = new VectorStore({ root: deps.root, model, baseDir: deps.baseDir, fsOps: deps.fsOps, log });
+  await store2.load();
+  try {
+    const rowByHash = /* @__PURE__ */ new Map();
+    const rowBySpan = /* @__PURE__ */ new Map();
+    store2.rows().forEach((row, i2) => {
+      rowByHash.set(row.hash, i2);
+      rowBySpan.set(spanKey(row.path, row.sig, row.startLine, row.endLine), i2);
+    });
+    const signatures = /* @__PURE__ */ new Map();
+    const embedBatch = async (batch) => {
+      let vectors = null;
+      for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+          const response = await deps.embeddings.embed({
+            texts: batch.map((m) => m.text),
+            inputType: "passage",
+            model,
+            sessionId: request.sessionId
+          });
+          if (response.vectors.length !== batch.length) {
+            throw new Error(`embedding batch answered ${response.vectors.length} vectors for ${batch.length} texts`);
+          }
+          vectors = response.vectors;
+          break;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          if (attempt < maxRetries - 1) {
+            const waitMs = 2 ** attempt * 1e3;
+            log(`orion: embedding batch failed (attempt ${attempt + 1}), retrying in ${waitMs / 1e3}s: ${message}`);
+            await sleep(waitMs);
+          } else {
+            log(`orion: embedding batch failed after ${maxRetries} attempts: ${message}`);
+          }
+        }
+      }
+      deps.onProgress?.();
+      if (!vectors) {
+        stats.failed_chunks += batch.length;
+        return;
+      }
+      const rows = [];
+      const rowVectors = [];
+      for (let i2 = 0; i2 < batch.length; i2++) {
+        const miss = batch[i2];
+        const known = rowByHash.get(miss.hash);
+        if (known !== void 0) {
+          miss.entry.rowIndex = known;
+          continue;
+        }
+        const rowIndex = store2.size() + rows.length;
+        rowByHash.set(miss.hash, rowIndex);
+        miss.entry.rowIndex = rowIndex;
+        rows.push({
+          hash: miss.hash,
+          path: miss.entry.chunk.path,
+          startLine: miss.entry.chunk.startLine,
+          endLine: miss.entry.chunk.endLine,
+          sig: signatures.get(miss.entry.chunk.path) ?? ""
+        });
+        rowVectors.push(Float32Array.from(vectors[i2]));
+      }
+      if (rows.length > 0) await store2.append(rows, rowVectors);
+      stats.chunks_embedded += batch.length;
+    };
+    let pending = [];
+    const embedPending = async () => {
+      if (pending.length === 0) return;
+      const batch = pending;
+      pending = [];
+      await embedBatch(batch);
+    };
+    for (const [relPath, entries] of byPath) {
+      const stat = await deps.stat(relPath);
+      if (!stat) continue;
+      const sig = fileSignature(stat);
+      signatures.set(relPath, sig);
+      const trusted = entries.every((entry) => {
+        const row = rowBySpan.get(spanKey(relPath, sig, entry.chunk.startLine, entry.chunk.endLine));
+        if (row === void 0) return false;
+        entry.rowIndex = row;
+        return true;
+      });
+      if (trusted) {
+        stats.cache_hits += entries.length;
+        continue;
+      }
+      const text = await deps.readFile(relPath);
+      if (text === null) continue;
+      const lines = text.split("\n");
+      for (const entry of entries) {
+        const rendered = embeddingText(relPath, entry.type, chunkSource(lines, entry.chunk.startLine, entry.chunk.endLine));
+        const hash = vectorContentHash(rendered);
+        const row = rowByHash.get(hash);
+        if (row !== void 0) {
+          entry.rowIndex = row;
+          stats.cache_hits += 1;
+          continue;
+        }
+        pending.push({ entry, text: rendered, hash });
+        if (pending.length >= batchSize) await embedPending();
+      }
+    }
+    await embedPending();
+    await store2.flush();
+    const liveRows = /* @__PURE__ */ new Map();
+    for (const entry of inventory) {
+      if (entry.rowIndex < 0) continue;
+      const list = liveRows.get(entry.rowIndex);
+      if (list) list.push(entry);
+      else liveRows.set(entry.rowIndex, [entry]);
+    }
+    const top = new TopK(Math.max(0, Math.min(request.topK, liveRows.size)));
+    if (query.length === store2.dims() && liveRows.size > 0) {
+      await store2.scan(
+        (rowIndex, vector) => top.offer(rowIndex, cosineAgainstNormalized(query, vector)),
+        (rowIndex) => liveRows.has(rowIndex)
+      );
+    } else if (liveRows.size > 0) {
+      log(`orion: query vector width ${query.length} does not match the layer's ${store2.dims()} \u2014 no ranking`);
+    }
+    const hits = [];
+    for (const { rowIndex, score } of top.entries()) {
+      for (const entry of liveRows.get(rowIndex) ?? []) {
+        hits.push({ ...describeChunk(entry, deps.symbolsFor(entry.chunk.path)), score });
+      }
+    }
+    hits.splice(request.topK);
+    const candidateFiles = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const hit of hits) {
+      if (seen.has(hit.path)) continue;
+      seen.add(hit.path);
+      candidateFiles.push(hit.path);
+    }
+    const files = [];
+    const fileChunks = {};
+    let sentBytes = 0;
+    let sentChars = 0;
+    for (const relPath of candidateFiles) {
+      const symbols = deps.symbolsFor(relPath);
+      fileChunks[relPath] = (byPath.get(relPath) ?? []).map((entry) => describeChunk(entry, symbols));
+      const content = await deps.readFile(relPath);
+      if (content === null) {
+        stats.files_truncated += 1;
+        continue;
+      }
+      const bytes = Buffer.byteLength(content, "utf8");
+      const overBudget = files.length > 0 && sentBytes + bytes > payloadBudget;
+      if (overBudget && sentChars >= request.rerankSourceChars) {
+        stats.files_truncated += 1;
+        continue;
+      }
+      files.push({ path: relPath, content });
+      sentBytes += bytes;
+      sentChars += content.length;
+    }
+    stats.files_sent = files.length;
+    const dead = store2.size() - liveRows.size;
+    if (dead >= COMPACT_MIN_DEAD_ROWS && dead >= store2.size() * COMPACT_DEAD_RATIO) {
+      const swept = await store2.compact((_row, rowIndex) => liveRows.has(rowIndex));
+      log(`orion: vector layer for ${model} compacted \u2014 kept ${swept.kept}, dropped ${swept.dropped}`);
+    }
+    stats.elapsed_ms = Math.max(0, now() - started);
+    return {
+      version: 1,
+      provider,
+      model,
+      dims: store2.dims() || query.length,
+      query_text: request.queryText,
+      hits,
+      candidate_files: candidateFiles,
+      files,
+      file_chunks: fileChunks,
+      stats
+    };
+  } finally {
+    await store2.close();
+  }
+}
+function describeChunk(entry, symbols) {
+  const { name: name2, parent } = chunkIdentity(entry.chunk, symbols);
+  return {
+    path: entry.chunk.path,
+    type: entry.type,
+    name: name2,
+    parent,
+    start_line: entry.chunk.startLine,
+    end_line: entry.chunk.endLine
+  };
+}
+function spanKey(relPath, sig, startLine, endLine) {
+  return `${relPath}\0${sig}\0${startLine}-${endLine}`;
+}
+function normalizeScope(scope) {
+  const trimmed = (scope ?? "").trim().replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
+  return trimmed === "." ? "" : trimmed;
+}
+function inScope(relPath, scope) {
+  return relPath === scope || relPath.startsWith(`${scope}/`);
+}
+
 // ../packages/orion-client-core/src/shims/fileSource.ts
 function emptyIndexStatusDetail() {
   return {
@@ -8047,6 +8716,31 @@ var WorkerWorkspaceIndexer = class extends WorkspaceIndexer {
     return adaptiveIndexHeapBudgetBytes();
   }
 };
+var hostNextId = 1;
+var hostPending = /* @__PURE__ */ new Map();
+function callHost(method, params) {
+  const id = hostNextId++;
+  return new Promise((resolve5, reject) => {
+    if (typeof process.send !== "function") {
+      reject(new Error("embeddings are unavailable: no IPC channel to the host"));
+      return;
+    }
+    hostPending.set(id, { resolve: resolve5, reject });
+    const msg = { hostRequest: id, method, params };
+    process.send(msg, (error) => {
+      if (!error) return;
+      hostPending.delete(id);
+      reject(error);
+    });
+  });
+}
+function settleHostResponse(msg) {
+  const pending = hostPending.get(msg.hostResponse);
+  if (!pending) return;
+  hostPending.delete(msg.hostResponse);
+  if (msg.ok) pending.resolve(msg.result);
+  else pending.reject(new Error(msg.error));
+}
 var config = {
   root: null,
   grammarDir: null,
@@ -8170,8 +8864,52 @@ var READ_METHODS = /* @__PURE__ */ new Set([
   "readContextHeader",
   "searchCodebase",
   "traceCodebase",
+  "enhancedRetrieve",
   "dependencyAdvisory"
 ]);
+async function runEnhancedRetrieve2(input) {
+  const root = config.root;
+  if (!root) return null;
+  const absolute = (rel) => path6.join(root, rel);
+  return await enhancedRetrieve(
+    {
+      queryText: String(input.query_text ?? ""),
+      topK: Number(input.top_k ?? 0),
+      rerankSourceChars: Number(input.rerank_source_chars ?? 0),
+      scope: input.scope,
+      sessionId: input.sessionId
+    },
+    {
+      root,
+      chunks: () => store.chunkIndex.collect(),
+      symbolsFor: (rel) => store.listSymbols(rel),
+      readFile: async (rel) => {
+        try {
+          return await import_fs4.promises.readFile(absolute(rel), "utf8");
+        } catch {
+          return null;
+        }
+      },
+      stat: async (rel) => {
+        try {
+          const s = await import_fs4.promises.stat(absolute(rel));
+          return { size: s.size, mtimeMs: s.mtimeMs };
+        } catch {
+          return null;
+        }
+      },
+      embeddings: {
+        embed: (request) => callHost("embed", request)
+      },
+      ...config.cacheBaseDir ? { baseDir: config.cacheBaseDir } : {},
+      log: (message) => console.log(message),
+      onProgress: () => {
+        lastActivityAt = Date.now();
+        send({ event: "progress", kind: "heartbeat" });
+      }
+    }
+  );
+}
 var WAKE_READ_WARM_WAIT_MS = 15e3;
 async function handle3(method, params) {
   if (READ_METHODS.has(method)) {
@@ -8201,19 +8939,14 @@ async function handle3(method, params) {
       return store.readContextHeader(
         String(params.path ?? ""),
         Number(params.line ?? 1),
-        String(params.mode ?? "full"),
-        params.options ?? {}
+        String(params.mode ?? "full")
       );
     case "searchCodebase":
-      return store.searchCodebase(
-        params.input ?? {},
-        params.options ?? {}
-      );
+      return store.searchCodebase(params.input ?? {});
     case "traceCodebase":
-      return store.traceCodebase(
-        params.input ?? {},
-        params.options ?? {}
-      );
+      return store.traceCodebase(params.input ?? {});
+    case "enhancedRetrieve":
+      return await runEnhancedRetrieve2(params.input ?? {});
     case "dependencyAdvisory":
       return buildDependencyAdvisory(
         String(params.path ?? ""),
@@ -8231,6 +8964,10 @@ async function handle3(method, params) {
   }
 }
 process.on("message", (msg) => {
+  if (msg && typeof msg === "object" && "hostResponse" in msg) {
+    settleHostResponse(msg);
+    return;
+  }
   if (!msg || typeof msg.id !== "number" || typeof msg.method !== "string") return;
   activeRequests += 1;
   lastActivityAt = Date.now();