@wrongstack/tools 1.0.1 → 1.0.3

package/dist/{chunk-N3K2SFEI.js → chunk-3JVSOBHU.js}

@@ -1,6 +1,9 @@
 import {
   parseFilesContent
-} from "./chunk-NU2IZ72J.js";
+} from "./chunk-6LCKF5KH.js";
+import {
+  recordFilesystemRead
+} from "./chunk-ZKC5UNGD.js";
 import {
   INDEXABLE_EXTENSIONS,
   LANG_FAMILY_ENTRIES,
@@ -94,6 +97,567 @@ function resetIndexCircuitBreaker() {
   indexCircuitBreaker.reset();
 }
 
+// src/codebase-index/graph-rank.ts
+var DEFAULT_RESTART = 0.25;
+var DEFAULT_ITERATIONS = 25;
+var UNVERIFIED_VISIBILITY_WEIGHT = 0.25;
+var CONTRADICTED_VISIBILITY_WEIGHT = 0.02;
+var WALK_RELATIONS = /* @__PURE__ */ new Set([
+  "call",
+  "import",
+  "type_ref",
+  "inherit",
+  "implement"
+]);
+function buildWiringGraph(refs, options = {}) {
+  const index = /* @__PURE__ */ new Map();
+  const idList = [];
+  const intern = (id) => {
+    const existing = index.get(id);
+    if (existing !== void 0) return existing;
+    const dense = idList.length;
+    index.set(id, dense);
+    idList.push(id);
+    return dense;
+  };
+  const candidates = options.candidates;
+  const fileOf = options.fileOf;
+  const importsOf = options.importsOf;
+  const checkVisibility = fileOf !== void 0 && importsOf !== void 0;
+  const from = [];
+  const to = [];
+  const weight = [];
+  for (const ref of refs) {
+    if (!WALK_RELATIONS.has(ref.callType)) continue;
+    if (ref.fromId === ref.toId) continue;
+    from.push(intern(ref.fromId));
+    to.push(intern(ref.toId));
+    const homonyms = candidates?.get(ref.toId) ?? 1;
+    let w = homonyms > 1 ? 1 / homonyms : 1;
+    if (checkVisibility) {
+      const sourceFile = fileOf.get(ref.fromId);
+      const targetFile = fileOf.get(ref.toId);
+      if (sourceFile !== void 0 && targetFile !== void 0 && sourceFile !== targetFile) {
+        const imports = importsOf.get(sourceFile);
+        if (imports === void 0) {
+          w *= UNVERIFIED_VISIBILITY_WEIGHT;
+        } else if (!imports.has(targetFile)) {
+          w *= CONTRADICTED_VISIBILITY_WEIGHT;
+        }
+      }
+    }
+    weight.push(w);
+  }
+  const size = idList.length;
+  const ids = Int32Array.from(idList);
+  const offsets = new Int32Array(size + 1);
+  const inDegree = new Int32Array(size);
+  const outDegree = new Int32Array(size);
+  if (size === 0) {
+    return {
+      size: 0,
+      ids,
+      index,
+      offsets,
+      neighbours: new Int32Array(0),
+      weights: new Float64Array(0),
+      inDegree,
+      outDegree
+    };
+  }
+  const counts = new Int32Array(size);
+  for (let e = 0; e < from.length; e++) {
+    const u = from[e];
+    const v = to[e];
+    counts[u] = counts[u] + 1;
+    counts[v] = counts[v] + 1;
+    outDegree[u] = outDegree[u] + 1;
+    inDegree[v] = inDegree[v] + 1;
+  }
+  let running = 0;
+  for (let u = 0; u < size; u++) {
+    offsets[u] = running;
+    running += counts[u];
+  }
+  offsets[size] = running;
+  const cursor = offsets.slice(0, size);
+  const neighbours = new Int32Array(running);
+  const weights = new Float64Array(running);
+  for (let e = 0; e < from.length; e++) {
+    const u = from[e];
+    const v = to[e];
+    const w = weight[e];
+    const cu = cursor[u];
+    neighbours[cu] = v;
+    weights[cu] = w;
+    cursor[u] = cu + 1;
+    const cv = cursor[v];
+    neighbours[cv] = u;
+    weights[cv] = w;
+    cursor[v] = cv + 1;
+  }
+  return { size, ids, index, offsets, neighbours, weights, inDegree, outDegree };
+}
+function pageRank(graph, options = {}) {
+  const { size, offsets, neighbours, weights } = graph;
+  const scores = new Float64Array(size);
+  if (size === 0) return scores;
+  const restart = options.restart ?? DEFAULT_RESTART;
+  const iterations = options.iterations ?? DEFAULT_ITERATIONS;
+  const walk = 1 - restart;
+  const restartDist = new Float64Array(size);
+  const seeds = options.seeds;
+  let seedTotal = 0;
+  if (seeds && seeds.size > 0) {
+    for (const [node, weight] of seeds) {
+      if (node < 0 || node >= size) continue;
+      if (!(weight > 0)) continue;
+      restartDist[node] = restartDist[node] + weight;
+      seedTotal += weight;
+    }
+  }
+  if (seedTotal > 0) {
+    for (let u = 0; u < size; u++) restartDist[u] = restartDist[u] / seedTotal;
+  } else {
+    restartDist.fill(1 / size);
+  }
+  let current = Float64Array.from(restartDist);
+  let next = new Float64Array(size);
+  for (let iter = 0; iter < iterations; iter++) {
+    next.fill(0);
+    let teleport = 0;
+    for (let u = 0; u < size; u++) {
+      const mass = current[u];
+      if (mass === 0) continue;
+      teleport += restart * mass;
+      const start = offsets[u];
+      const end = offsets[u + 1];
+      const degree = end - start;
+      if (degree === 0) {
+        teleport += walk * mass;
+        continue;
+      }
+      const outgoing = walk * mass;
+      const share = outgoing / degree;
+      let moved = 0;
+      for (let e = start; e < end; e++) {
+        const target = neighbours[e];
+        const transfer = share * weights[e];
+        next[target] = next[target] + transfer;
+        moved += transfer;
+      }
+      teleport += outgoing - moved;
+    }
+    if (teleport > 0) {
+      for (let u = 0; u < size; u++) {
+        next[u] = next[u] + teleport * restartDist[u];
+      }
+    }
+    const swap = current;
+    current = next;
+    next = swap;
+  }
+  let max = 0;
+  for (let u = 0; u < size; u++) {
+    const value = current[u];
+    if (value > max) max = value;
+  }
+  if (max > 0) {
+    for (let u = 0; u < size; u++) scores[u] = current[u] / max;
+  }
+  return scores;
+}
+function toSymbolRankRows(graph, scores) {
+  const rows = new Array(graph.size);
+  for (let u = 0; u < graph.size; u++) {
+    rows[u] = {
+      symbolId: graph.ids[u],
+      rank: scores[u],
+      inDeg: graph.inDegree[u],
+      outDeg: graph.outDegree[u]
+    };
+  }
+  return rows;
+}
+function aggregateFileRank(rows, fileOf) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const file = fileOf.get(row.symbolId);
+    if (file === void 0) continue;
+    const existing = byFile.get(file);
+    if (existing === void 0) {
+      byFile.set(file, {
+        file,
+        rank: row.rank,
+        inDeg: row.inDeg,
+        outDeg: row.outDeg
+      });
+      continue;
+    }
+    existing.rank += row.rank;
+    existing.inDeg += row.inDeg;
+    existing.outDeg += row.outDeg;
+  }
+  let max = 0;
+  for (const row of byFile.values()) {
+    if (row.rank > max) max = row.rank;
+  }
+  const out = [...byFile.values()];
+  if (max > 0) {
+    for (const row of out) row.rank /= max;
+  }
+  return out;
+}
+
+// src/codebase-index/graph-adjacency-cache.ts
+var cached = null;
+function cacheKey(projectRoot, indexDir) {
+  return `${projectRoot}\0${indexDir ?? ""}`;
+}
+function contentStamp(store) {
+  const counts = store.getRankCounts();
+  return [
+    store.getMetadata("last_indexed") ?? "",
+    store.getMetadata("relation_graph_version") ?? "",
+    counts.symbols,
+    counts.files
+  ].join("|");
+}
+function getWiringSnapshot(store, projectRoot, indexDir) {
+  const key = cacheKey(projectRoot, indexDir);
+  const stamp = contentStamp(store);
+  if (cached !== null && cached.key === key && cached.stamp === stamp) {
+    return { graph: cached.graph, fileOf: cached.fileOf };
+  }
+  const fileOf = /* @__PURE__ */ new Map();
+  for (const symbol of store.getAllSymbols()) fileOf.set(symbol.id, symbol.file);
+  const graph = buildWiringGraph(store.getAllResolvedRefs(), {
+    candidates: store.getSymbolNameCandidates(),
+    fileOf,
+    importsOf: store.getImportVisibility()
+  });
+  cached = { key, stamp, graph, fileOf };
+  return { graph, fileOf };
+}
+function clearWiringSnapshot() {
+  cached = null;
+}
+
+// src/codebase-index/writer-helpers.ts
+import { resolveWstackPaths } from "@wrongstack/core/utils";
+function escapeLike(value) {
+  return /[\\%_]/.test(value) ? value.replace(/[\\%_]/g, (char) => `\\${char}`) : value;
+}
+function ladderChunkSizes(total, max) {
+  if (total <= 0) return [];
+  const sizes = [];
+  let remaining = total;
+  while (remaining > 0) {
+    const cap = Math.min(remaining, max);
+    const pow = cap >= 1 ? 2 ** Math.floor(Math.log2(cap)) : 1;
+    const take = Math.max(1, Math.min(pow, remaining));
+    sizes.push(take);
+    remaining -= take;
+  }
+  return sizes;
+}
+function nextPow2(count) {
+  return count <= 1 ? 1 : 2 ** Math.ceil(Math.log2(count));
+}
+function padToInBucket(values) {
+  if (values.length <= 1) return values.slice();
+  const target = nextPow2(values.length);
+  const padded = values.slice();
+  while (padded.length < target) padded.push(padded[0]);
+  return padded;
+}
+var PLACEHOLDER_BUCKETS = {
+  1: "?",
+  2: "?,?",
+  4: "?,?,?,?",
+  8: "?,?,?,?,?,?,?,?",
+  16: "?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?",
+  32: "?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?",
+  64: "?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?",
+  128: Array.from({ length: 128 }, () => "?").join(","),
+  256: Array.from({ length: 256 }, () => "?").join(","),
+  512: Array.from({ length: 512 }, () => "?").join(","),
+  1024: Array.from({ length: 1024 }, () => "?").join(",")
+};
+function placeholders(count) {
+  if (count <= 0) return "";
+  return PLACEHOLDER_BUCKETS[count] ?? Array.from({ length: count }, () => "?").join(",");
+}
+function inListChunks(total, max) {
+  if (total <= 0) return [];
+  if (nextPow2(total) <= max) return [total];
+  const powMax = Math.max(1, 2 ** Math.floor(Math.log2(max)));
+  return ladderChunkSizes(total, powMax);
+}
+function posixIndexPath(file) {
+  const p = file.includes("\\") ? file.replace(/\\/g, "/") : file;
+  return p.startsWith("./") ? p.slice(2) : p;
+}
+function indexedFileMatchSql(column = "file") {
+  return `(${column} = ? OR replace(${column}, '\\', '/') = ? OR replace(${column}, '\\', '/') LIKE ? ESCAPE '\\')`;
+}
+function indexedFileMatchArgs(file) {
+  const posix4 = posixIndexPath(file.trim());
+  return [file, posix4, `%/${escapeLike(posix4)}`];
+}
+function matchesIndexedPackageFilter(storedFile, packageLabel, filter) {
+  if (packageLabel === filter) return true;
+  const posixFile = posixIndexPath(storedFile);
+  const posixFilter = posixIndexPath(filter.trim());
+  if (!posixFilter) return false;
+  return posixFile === posixFilter || posixFile.endsWith(`/${posixFilter}`) || posixFile.includes(`/${posixFilter}/`);
+}
+function assignRefsToSymbols(refs, symbols) {
+  if (refs.length === 0 || symbols.length === 0) return [];
+  const ordered = [...symbols].sort((a, b) => a.line - b.line || a.col - b.col || a.id - b.id);
+  const seen = /* @__PURE__ */ new Set();
+  const assigned = [];
+  for (const ref of refs) {
+    let owner;
+    for (const symbol of ordered) {
+      if (symbol.line > ref.line) break;
+      owner = symbol;
+    }
+    if (!owner && ref.callType === "import") owner = ordered[0];
+    if (!owner || owner.id <= 0) continue;
+    const key = `${owner.id}:${ref.toName}:${ref.callType}:${ref.module ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    assigned.push({ ...ref, fromId: owner.id });
+  }
+  return assigned;
+}
+function resolveIndexDir(projectRoot, override) {
+  return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
+}
+function codebaseIndexDirOverride(ctx) {
+  const v = ctx.meta?.["codebaseIndexDir"];
+  return typeof v === "string" ? v : void 0;
+}
+
+// src/codebase-index/context-retrieval.ts
+var SEED_LIMIT = 40;
+var DEFAULT_LIMIT = 12;
+var DEFAULT_SYMBOLS_PER_FILE = 4;
+var NODE_HYDRATION_LIMIT = 400;
+var SEMANTIC_SYMBOLS_PER_FILE = 3;
+var SEMANTIC_SEED_SHARE = 0.35;
+function normalisePrefix(prefix) {
+  if (prefix === void 0) return void 0;
+  const trimmed = posixIndexPath(prefix.trim()).replace(/\/+$/, "");
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function retrieveContext(store, projectRoot, indexDir, options, relativeOf) {
+  const query = options.query.trim();
+  const limit = Math.max(1, Math.min(options.limit ?? DEFAULT_LIMIT, 50));
+  const symbolsPerFile = Math.max(
+    1,
+    Math.min(options.symbolsPerFile ?? DEFAULT_SYMBOLS_PER_FILE, 20)
+  );
+  const prefix = normalisePrefix(options.pathPrefix);
+  const vectorFiles = options.vectorFiles ?? [];
+  const empty = (indexStatus) => ({
+    query,
+    entries: [],
+    seedCount: 0,
+    semanticSeedCount: 0,
+    totalCandidates: 0,
+    indexStatus
+  });
+  if (query.length === 0) return empty("no-matches");
+  const search = store.searchRanked(query, void 0, SEED_LIMIT);
+  if (search.results.length === 0 && vectorFiles.length === 0) {
+    return empty(store.getIndexSummary().totalFiles === 0 ? "no-index" : "no-matches");
+  }
+  const { graph, fileOf } = getWiringSnapshot(store, projectRoot, indexDir);
+  if (graph.size === 0) {
+    return {
+      ...groupIntoEntries(
+        search.results,
+        /* @__PURE__ */ new Map(),
+        fileOf,
+        limit,
+        symbolsPerFile,
+        prefix,
+        relativeOf
+      ),
+      query,
+      seedCount: search.results.length,
+      semanticSeedCount: vectorFiles.length,
+      indexStatus: "unranked"
+    };
+  }
+  const seeds = /* @__PURE__ */ new Map();
+  let lexicalMass = 0;
+  for (const hit of search.results) {
+    const dense = graph.index.get(hit.id);
+    if (dense === void 0) continue;
+    const weight = hit.score > 0 ? hit.score : 1;
+    lexicalMass += weight;
+    seeds.set(dense, (seeds.get(dense) ?? 0) + weight);
+  }
+  const semanticSeeds = /* @__PURE__ */ new Map();
+  for (const hit of vectorFiles) {
+    if (!(hit.score > 0)) continue;
+    for (const symbol of store.getFileSymbols(hit.file, SEMANTIC_SYMBOLS_PER_FILE)) {
+      const dense = graph.index.get(symbol.id);
+      if (dense === void 0) continue;
+      semanticSeeds.set(dense, (semanticSeeds.get(dense) ?? 0) + hit.score);
+    }
+  }
+  if (semanticSeeds.size > 0) {
+    let semanticMass = 0;
+    for (const weight of semanticSeeds.values()) semanticMass += weight;
+    const scale = semanticMass > 0 && lexicalMass > 0 ? lexicalMass * SEMANTIC_SEED_SHARE / semanticMass : 1;
+    for (const [dense, weight] of semanticSeeds) {
+      seeds.set(dense, (seeds.get(dense) ?? 0) + weight * scale);
+    }
+  }
+  if (seeds.size === 0) {
+    return {
+      ...groupIntoEntries(
+        search.results,
+        /* @__PURE__ */ new Map(),
+        fileOf,
+        limit,
+        symbolsPerFile,
+        prefix,
+        relativeOf
+      ),
+      query,
+      seedCount: search.results.length,
+      semanticSeedCount: vectorFiles.length,
+      indexStatus: "unranked"
+    };
+  }
+  const scores = pageRank(graph, { seeds });
+  const ordered = [];
+  for (let u = 0; u < graph.size; u++) {
+    const score = scores[u];
+    if (score > 0) ordered.push({ dense: u, score });
+  }
+  ordered.sort((a, b) => b.score - a.score);
+  const top = ordered.slice(0, NODE_HYDRATION_LIMIT);
+  const scoreBySymbolId = /* @__PURE__ */ new Map();
+  for (const node of top) scoreBySymbolId.set(graph.ids[node.dense], node.score);
+  const hydrated = store.getSymbolsByIds([...scoreBySymbolId.keys()]);
+  const seedIds = new Set(search.results.map((hit) => hit.id));
+  const walked = hydrated.map((row) => ({
+    id: row.id,
+    name: row.name,
+    kind: row.kind,
+    lang: row.lang,
+    file: row.file,
+    line: row.line,
+    col: 0,
+    signature: row.signature,
+    docComment: "",
+    score: scoreBySymbolId.get(row.id) ?? 0,
+    snippet: ""
+  }));
+  const grouped = groupIntoEntries(
+    walked,
+    scoreBySymbolId,
+    fileOf,
+    limit,
+    symbolsPerFile,
+    prefix,
+    relativeOf,
+    seedIds
+  );
+  return {
+    ...grouped,
+    query,
+    seedCount: search.results.length,
+    semanticSeedCount: vectorFiles.length,
+    indexStatus: "ok"
+  };
+}
+function groupIntoEntries(symbols, scoreBySymbolId, fileOf, limit, symbolsPerFile, prefix, relativeOf, seedIds = /* @__PURE__ */ new Set()) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const symbol of symbols) {
+    const storedFile = symbol.file || fileOf.get(symbol.id) || "";
+    if (!storedFile) continue;
+    const relative3 = relativeOf(storedFile);
+    if (prefix !== void 0 && relative3 !== prefix && !relative3.startsWith(`${prefix}/`)) continue;
+    const score = scoreBySymbolId.get(symbol.id) ?? symbol.score;
+    const seed = seedIds.has(symbol.id);
+    const entry = {
+      name: symbol.name,
+      kind: symbol.kind,
+      line: symbol.line,
+      signature: symbol.signature,
+      seed,
+      score
+    };
+    const bucket = byFile.get(relative3);
+    if (bucket === void 0) {
+      byFile.set(relative3, { file: relative3, best: score, matched: seed, symbols: [entry] });
+      continue;
+    }
+    bucket.symbols.push(entry);
+    if (score > bucket.best) bucket.best = score;
+    if (seed) bucket.matched = true;
+  }
+  const buckets = [...byFile.values()].sort(
+    (a, b) => b.best - a.best || a.file.localeCompare(b.file)
+  );
+  const totalCandidates = buckets.length;
+  const top = buckets.slice(0, limit);
+  const max = top[0]?.best ?? 0;
+  const entries = top.map((bucket) => ({
+    file: bucket.file,
+    relevance: max > 0 ? bucket.best / max : 0,
+    matched: bucket.matched,
+    symbols: bucket.symbols.sort((a, b) => Number(b.seed) - Number(a.seed) || b.score - a.score || a.line - b.line).slice(0, symbolsPerFile).map(({ score: _score, ...rest }) => rest)
+  }));
+  return { entries, totalCandidates };
+}
+
+// src/codebase-index/graph-rank-pass.ts
+var RANK_VERSION = "1";
+var RANK_VERSION_KEY = "rank_version";
+var RANK_REFRESH_FILE_THRESHOLD = 25;
+function shouldRefreshRanks(store, opts) {
+  if (opts.force) return true;
+  if (!opts.files) return true;
+  if (store.getMetadata(RANK_VERSION_KEY) !== RANK_VERSION) return true;
+  if (store.getRankCounts().symbols === 0) return true;
+  return opts.files.length >= RANK_REFRESH_FILE_THRESHOLD;
+}
+function runGraphRankPass(store, errors) {
+  const startMs = Date.now();
+  try {
+    const refs = store.getAllResolvedRefs();
+    const fileOf = /* @__PURE__ */ new Map();
+    for (const symbol of store.getAllSymbols()) fileOf.set(symbol.id, symbol.file);
+    const graph = buildWiringGraph(refs, {
+      candidates: store.getSymbolNameCandidates(),
+      fileOf,
+      importsOf: store.getImportVisibility()
+    });
+    const scores = pageRank(graph);
+    const symbolRows = toSymbolRankRows(graph, scores);
+    const fileRows = aggregateFileRank(symbolRows, fileOf);
+    store.replaceRanks(symbolRows, fileRows);
+    store.setMetadata(RANK_VERSION_KEY, RANK_VERSION);
+    return {
+      computed: true,
+      symbols: symbolRows.length,
+      files: fileRows.length,
+      durationMs: Date.now() - startMs
+    };
+  } catch (error) {
+    errors.push(`graph rank: ${error instanceof Error ? error.message : String(error)}`);
+    return { computed: false, symbols: 0, files: 0, durationMs: Date.now() - startMs };
+  }
+}
+
 // src/codebase-index/bm25.ts
 var K1 = 1.5;
 var B = 0.75;
@@ -232,101 +796,244 @@ var Bm25Index = class {
 // src/codebase-index/schema.ts
 var SCHEMA_VERSION = 5;
 
-// src/codebase-index/writer-helpers.ts
-import { resolveWstackPaths } from "@wrongstack/core/utils";
-function escapeLike(value) {
-  return /[\\%_]/.test(value) ? value.replace(/[\\%_]/g, (char) => `\\${char}`) : value;
-}
-function ladderChunkSizes(total, max) {
-  if (total <= 0) return [];
-  const sizes = [];
-  let remaining = total;
-  while (remaining > 0) {
-    const cap = Math.min(remaining, max);
-    const pow = cap >= 1 ? 2 ** Math.floor(Math.log2(cap)) : 1;
-    const take = Math.max(1, Math.min(pow, remaining));
-    sizes.push(take);
-    remaining -= take;
-  }
-  return sizes;
+// src/codebase-index/writer-concepts.ts
+var CONCEPT_RELATIONS = [
+  "uses",
+  "configures",
+  "validates",
+  "extends",
+  "persists",
+  "observes"
+];
+function isConceptRelation(value) {
+  return CONCEPT_RELATIONS.includes(value);
 }
-function nextPow2(count) {
-  return count <= 1 ? 1 : 2 ** Math.ceil(Math.log2(count));
+var SELECT_CONCEPT = "SELECT file, content_hash AS contentHash, summary, crux_start AS cruxStart, crux_end AS cruxEnd, state, model, updated_at AS updatedAt FROM file_concepts";
+function toConcept(row) {
+  return {
+    file: row.file,
+    contentHash: row.contentHash,
+    summary: row.summary,
+    cruxStart: row.cruxStart,
+    cruxEnd: row.cruxEnd,
+    state: row.state === "ready" || row.state === "stale" ? row.state : "pending",
+    model: row.model,
+    updatedAt: row.updatedAt
+  };
 }
-function padToInBucket(values) {
-  if (values.length <= 1) return values.slice();
-  const target = nextPow2(values.length);
-  const padded = values.slice();
-  while (padded.length < target) padded.push(padded[0]);
-  return padded;
+function upsertFileConceptWithStatement(stmt, concept) {
+  stmt(
+    `INSERT INTO file_concepts(file, content_hash, summary, crux_start, crux_end, state, model, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(file) DO UPDATE SET
+       content_hash = excluded.content_hash,
+       summary = excluded.summary,
+       crux_start = excluded.crux_start,
+       crux_end = excluded.crux_end,
+       state = excluded.state,
+       model = excluded.model,
+       updated_at = excluded.updated_at`
+  ).run(
+    concept.file,
+    concept.contentHash,
+    concept.summary,
+    concept.cruxStart,
+    concept.cruxEnd,
+    concept.state,
+    concept.model,
+    concept.updatedAt
+  );
 }
-var PLACEHOLDER_BUCKETS = {
-  1: "?",
-  2: "?,?",
-  4: "?,?,?,?",
-  8: "?,?,?,?,?,?,?,?",
-  16: "?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?",
-  32: "?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?",
-  64: "?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?",
-  128: Array.from({ length: 128 }, () => "?").join(","),
-  256: Array.from({ length: 256 }, () => "?").join(","),
-  512: Array.from({ length: 512 }, () => "?").join(","),
-  1024: Array.from({ length: 1024 }, () => "?").join(",")
-};
-function placeholders(count) {
-  if (count <= 0) return "";
-  return PLACEHOLDER_BUCKETS[count] ?? Array.from({ length: count }, () => "?").join(",");
+function getFileConceptWithStatement(stmt, file) {
+  const row = stmt(`${SELECT_CONCEPT} WHERE file = ?`).get(file);
+  return row === void 0 ? void 0 : toConcept(row);
 }
-function inListChunks(total, max) {
-  if (total <= 0) return [];
-  if (nextPow2(total) <= max) return [total];
-  const powMax = Math.max(1, 2 ** Math.floor(Math.log2(max)));
-  return ladderChunkSizes(total, powMax);
+function getAllFileConceptsWithStatement(stmt) {
+  return stmt(SELECT_CONCEPT).all().map(toConcept);
 }
-function posixIndexPath(file) {
-  const p = file.includes("\\") ? file.replace(/\\/g, "/") : file;
-  return p.startsWith("./") ? p.slice(2) : p;
+function getReadyConceptSummariesWithStatement(stmt) {
+  const rows = stmt(
+    "SELECT file, summary FROM file_concepts WHERE state = 'ready' AND summary <> ''"
+  ).all();
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) map.set(row.file, row.summary);
+  return map;
 }
-function indexedFileMatchSql(column = "file") {
-  return `(${column} = ? OR replace(${column}, '\\', '/') = ? OR replace(${column}, '\\', '/') LIKE ? ESCAPE '\\')`;
+function getConceptCoverageWithStatement(stmt) {
+  const rows = stmt(
+    "SELECT state, COUNT(*) AS n FROM file_concepts GROUP BY state"
+  ).all();
+  const coverage = { ready: 0, stale: 0, pending: 0, subsystems: 0 };
+  for (const row of rows) {
+    if (row.state === "ready") coverage.ready = row.n;
+    else if (row.state === "stale") coverage.stale = row.n;
+    else coverage.pending += row.n;
+  }
+  coverage.subsystems = Number(
+    stmt("SELECT COUNT(*) AS n FROM subsystems").get()?.n ?? 0
+  );
+  return coverage;
+}
+function markStaleConceptsWithStatement(stmt) {
+  const result = stmt(
+    `UPDATE file_concepts SET state = 'stale'
+     WHERE state = 'ready'
+       AND content_hash <> ''
+       AND content_hash <> COALESCE((SELECT f.content_hash FROM files f WHERE f.file = file_concepts.file), content_hash)`
+  ).run();
+  return Number(result.changes ?? 0);
+}
+function pruneOrphanConceptsWithStatement(stmt) {
+  const result = stmt("DELETE FROM file_concepts WHERE file NOT IN (SELECT file FROM files)").run();
+  return Number(result.changes ?? 0);
+}
+function replaceSubsystemsWithStatement(stmt, maxSqlVars, subsystems, edges) {
+  stmt("DELETE FROM subsystems").run();
+  stmt("DELETE FROM concept_edges").run();
+  if (subsystems.length > 0) {
+    const insert = stmt(
+      `INSERT INTO subsystems(id, name, summary, member_files, model, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    for (const subsystem of subsystems) {
+      insert.run(
+        subsystem.id,
+        subsystem.name,
+        subsystem.summary,
+        JSON.stringify(subsystem.memberFiles),
+        subsystem.model,
+        subsystem.updatedAt
+      );
+    }
+  }
+  if (edges.length === 0) return;
+  const ladder = ladderChunkSizes(edges.length, Math.max(1, Math.floor(maxSqlVars / 3)));
+  let cursor = 0;
+  for (const take of ladder) {
+    const chunk = edges.slice(cursor, cursor + take);
+    cursor += take;
+    const placeholders2 = chunk.map(() => "(?, ?, ?)").join(", ");
+    stmt(
+      `INSERT OR IGNORE INTO concept_edges(from_id, to_id, relation) VALUES ${placeholders2}`
+    ).run(...chunk.flatMap((edge) => [edge.fromId, edge.toId, edge.relation]));
+  }
 }
-function indexedFileMatchArgs(file) {
-  const posix4 = posixIndexPath(file.trim());
-  return [file, posix4, `%/${escapeLike(posix4)}`];
+function getSubsystemsWithStatement(stmt) {
+  const rows = stmt(
+    "SELECT id, name, summary, member_files AS memberFiles, model, updated_at AS updatedAt FROM subsystems ORDER BY id ASC"
+  ).all();
+  return rows.map((row) => {
+    let memberFiles = [];
+    try {
+      const parsed = JSON.parse(row.memberFiles);
+      if (Array.isArray(parsed))
+        memberFiles = parsed.filter((f) => typeof f === "string");
+    } catch {
+    }
+    return { ...row, memberFiles };
+  });
 }
-function matchesIndexedPackageFilter(storedFile, packageLabel, filter) {
-  if (packageLabel === filter) return true;
-  const posixFile = posixIndexPath(storedFile);
-  const posixFilter = posixIndexPath(filter.trim());
-  if (!posixFilter) return false;
-  return posixFile === posixFilter || posixFile.endsWith(`/${posixFilter}`) || posixFile.includes(`/${posixFilter}/`);
+function getConceptEdgesWithStatement(stmt) {
+  return stmt(
+    "SELECT from_id AS fromId, to_id AS toId, relation FROM concept_edges ORDER BY from_id, to_id, relation"
+  ).all().flatMap(
+    (row) => isConceptRelation(row.relation) ? [{ fromId: row.fromId, toId: row.toId, relation: row.relation }] : []
+  );
 }
-function assignRefsToSymbols(refs, symbols) {
-  if (refs.length === 0 || symbols.length === 0) return [];
-  const ordered = [...symbols].sort((a, b) => a.line - b.line || a.col - b.col || a.id - b.id);
-  const seen = /* @__PURE__ */ new Set();
-  const assigned = [];
-  for (const ref of refs) {
-    let owner;
-    for (const symbol of ordered) {
-      if (symbol.line > ref.line) break;
-      owner = symbol;
+
+// src/codebase-index/writer-graph-decorate.ts
+var MAX_SQL_VARS = 900;
+function normaliseInPlace(nodes) {
+  let localMax = 0;
+  let anyMax = 0;
+  for (const node of nodes) {
+    const rank = node.rank;
+    if (rank === void 0) continue;
+    if (rank > anyMax) anyMax = rank;
+    if (node.external !== true && rank > localMax) localMax = rank;
+  }
+  const max = localMax > 0 ? localMax : anyMax;
+  if (max <= 0) return;
+  for (const node of nodes) {
+    if (node.rank !== void 0) node.rank = Math.min(1, node.rank / max);
+  }
+}
+function decorateGraphNodes(stmt, nodes, packageOf) {
+  if (nodes.length === 0) return;
+  const fileRank = /* @__PURE__ */ new Map();
+  for (const row of stmt("SELECT file, rank FROM file_rank").all()) {
+    fileRank.set(row.file, row.rank);
+  }
+  const mtime = /* @__PURE__ */ new Map();
+  for (const row of stmt("SELECT file, mtime_ms FROM files").all()) {
+    mtime.set(row.file, row.mtime_ms);
+  }
+  const concepts = /* @__PURE__ */ new Map();
+  for (const row of stmt(
+    "SELECT file, summary, crux_start, crux_end FROM file_concepts WHERE state = 'ready' AND summary != ''"
+  ).all()) {
+    concepts.set(row.file, row);
+  }
+  const subsystems = /* @__PURE__ */ new Map();
+  for (const row of stmt("SELECT id, name, summary FROM subsystems").all()) {
+    subsystems.set(row.id, { name: row.name, summary: row.summary });
+  }
+  const symbolRank = /* @__PURE__ */ new Map();
+  const symbolIds = nodes.map((node) => node.symbolId).filter((id) => typeof id === "number");
+  for (let start = 0; start < symbolIds.length; start += MAX_SQL_VARS) {
+    const chunk = symbolIds.slice(start, start + MAX_SQL_VARS);
+    const placeholders2 = chunk.map(() => "?").join(",");
+    for (const row of stmt(
+      `SELECT symbol_id, rank FROM symbol_rank WHERE symbol_id IN (${placeholders2})`
+    ).all(...chunk)) {
+      symbolRank.set(row.symbol_id, row.rank);
     }
-    if (!owner && ref.callType === "import") owner = ordered[0];
-    if (!owner || owner.id <= 0) continue;
-    const key = `${owner.id}:${ref.toName}:${ref.callType}:${ref.module ?? ""}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    assigned.push({ ...ref, fromId: owner.id });
   }
-  return assigned;
-}
-function resolveIndexDir(projectRoot, override) {
-  return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
-}
-function codebaseIndexDirOverride(ctx) {
-  const v = ctx.meta?.["codebaseIndexDir"];
-  return typeof v === "string" ? v : void 0;
+  const packageRank = /* @__PURE__ */ new Map();
+  if (nodes.some((node) => node.kind === "package")) {
+    for (const [file, rank] of fileRank) {
+      const pkg = packageOf(file);
+      packageRank.set(pkg, (packageRank.get(pkg) ?? 0) + rank);
+    }
+  }
+  for (const node of nodes) {
+    if (node.kind === "package") {
+      const pkg = node.package;
+      if (pkg === void 0) continue;
+      const rank = packageRank.get(pkg);
+      if (rank !== void 0) node.rank = rank;
+      const subsystem2 = subsystems.get(pkg);
+      if (subsystem2 !== void 0) {
+        node.subsystem = subsystem2.name;
+        if (subsystem2.summary !== "") node.concept = subsystem2.summary;
+      }
+      continue;
+    }
+    const file = node.file;
+    if (file === void 0) continue;
+    const modified = mtime.get(file);
+    if (modified !== void 0) node.lastModifiedMs = modified;
+    const subsystem = subsystems.get(packageOf(file));
+    if (subsystem !== void 0) node.subsystem = subsystem.name;
+    if (node.kind === "file") {
+      const rank = fileRank.get(file);
+      if (rank !== void 0) node.rank = rank;
+      const concept = concepts.get(file);
+      if (concept !== void 0) {
+        node.concept = concept.summary;
+        if (concept.crux_start !== null && concept.crux_end !== null) {
+          node.crux = { start: concept.crux_start, end: concept.crux_end };
+        }
+      }
+      continue;
+    }
+    const symbolId = node.symbolId;
+    if (symbolId !== void 0) {
+      const rank = symbolRank.get(symbolId);
+      if (rank !== void 0) node.rank = rank;
+    }
+  }
+  normaliseInPlace(nodes);
 }
 
 // src/codebase-index/lsp-kind.ts
@@ -391,6 +1098,145 @@ function internalKindToLspKind(k) {
   }
 }
 
+// src/codebase-index/vector-search.ts
+var RRF_K = 60;
+function vectorEmbeddingEnabled() {
+  return process.env["WRONGSTACK_INDEX_VECTORS"] === "1";
+}
+var VECTOR_DIMENSIONS = 384;
+var NGRAM_SIZE = 3;
+function embedText(text) {
+  const vec = new Float32Array(VECTOR_DIMENSIONS);
+  const normalized = text.toLowerCase().trim();
+  if (normalized.length === 0) return vec;
+  const target = normalized.length < NGRAM_SIZE ? ` ${normalized} `.slice(0, Math.max(NGRAM_SIZE, normalized.length + 2)) : normalized;
+  for (let i = 0; i <= target.length - NGRAM_SIZE; i++) {
+    const ngram = target.slice(i, i + NGRAM_SIZE);
+    const bucket = hashNgram(ngram) % VECTOR_DIMENSIONS;
+    vec[bucket] += 1;
+  }
+  let norm = 0;
+  for (let i = 0; i < VECTOR_DIMENSIONS; i++) {
+    norm += vec[i] * vec[i];
+  }
+  norm = Math.sqrt(norm);
+  if (norm > 0) {
+    for (let i = 0; i < VECTOR_DIMENSIONS; i++) {
+      vec[i] /= norm;
+    }
+  }
+  return vec;
+}
+function hashNgram(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+function encodeVector(vec) {
+  return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+function decodeVector(buf) {
+  if (buf.byteLength === 0) return new Float32Array(0);
+  if (buf.byteLength % 4 !== 0) {
+    throw new Error(
+      `decodeVector: invalid vector byteLength ${buf.byteLength} (must be a multiple of 4)`
+    );
+  }
+  const copy = new Float32Array(buf.byteLength / 4);
+  new Uint8Array(copy.buffer).set(buf);
+  return copy;
+}
+function reciprocalRankFusion(bm25Ranks, vectorRanks, k = RRF_K) {
+  const allIds = /* @__PURE__ */ new Set([...bm25Ranks.keys(), ...vectorRanks.keys()]);
+  const scored = [];
+  for (const id of allIds) {
+    const bm25Rank = bm25Ranks.get(id);
+    const vecRank = vectorRanks.get(id);
+    let score = 0;
+    if (bm25Rank !== void 0) score += 1 / (k + bm25Rank);
+    if (vecRank !== void 0) score += 1 / (k + vecRank);
+    scored.push([id, score]);
+  }
+  scored.sort((a, b) => b[1] - a[1]);
+  return scored;
+}
+
+// src/codebase-index/writer-vectors.ts
+var FILE_VECTOR_PROVIDER_KEY = "file_vector_provider";
+function getFileVectorStatesWithStatement(stmt, provider) {
+  const rows = stmt(
+    "SELECT file, source_hash AS sourceHash FROM file_vectors WHERE provider = ?"
+  ).all(provider);
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) map.set(row.file, row.sourceHash);
+  return map;
+}
+function upsertFileVectorsWithStatement(stmt, maxSqlVars, rows) {
+  if (rows.length === 0) return;
+  const ladder = ladderChunkSizes(rows.length, Math.max(1, Math.floor(maxSqlVars / 4)));
+  let cursor = 0;
+  for (const take of ladder) {
+    const chunk = rows.slice(cursor, cursor + take);
+    cursor += take;
+    const placeholders2 = chunk.map(() => "(?, ?, ?, ?)").join(", ");
+    stmt(
+      `INSERT INTO file_vectors(file, vector, source_hash, provider) VALUES ${placeholders2}
+       ON CONFLICT(file) DO UPDATE SET
+         vector = excluded.vector,
+         source_hash = excluded.source_hash,
+         provider = excluded.provider`
+    ).run(
+      ...chunk.flatMap((row) => [row.file, encodeVector(row.vector), row.sourceHash, row.provider])
+    );
+  }
+}
+function reconcileVectorProviderWithStatement(stmt, getMetadata, setMetadata, provider) {
+  const stored = getMetadata(FILE_VECTOR_PROVIDER_KEY);
+  if (stored === provider) return false;
+  stmt("DELETE FROM file_vectors").run();
+  setMetadata(FILE_VECTOR_PROVIDER_KEY, provider);
+  return stored !== void 0;
+}
+function pruneOrphanFileVectorsWithStatement(stmt) {
+  const result = stmt("DELETE FROM file_vectors WHERE file NOT IN (SELECT file FROM files)").run();
+  return Number(result.changes ?? 0);
+}
+function countFileVectorsWithStatement(stmt) {
+  return Number(
+    stmt("SELECT COUNT(*) AS n FROM file_vectors").get()?.n ?? 0
+  );
+}
+function searchFileVectorsWithStatement(stmt, query, limit, minScore) {
+  if (limit <= 0 || query.length === 0) return [];
+  const rows = stmt("SELECT file, vector FROM file_vectors").all();
+  const hits = [];
+  for (const row of rows) {
+    let vector;
+    try {
+      vector = decodeVector(row.vector);
+    } catch {
+      continue;
+    }
+    if (vector.length !== query.length) continue;
+    let dot = 0;
+    for (let i = 0; i < query.length; i++) dot += query[i] * vector[i];
+    if (dot >= minScore) hits.push({ file: row.file, score: dot });
+  }
+  hits.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
+  return hits.slice(0, limit);
+}
+
 // src/codebase-index/writer.ts
 import * as fs3 from "node:fs";
 import * as path3 from "node:path";
@@ -924,8 +1770,8 @@ function assignPackageLabels(structure, files) {
       const owner2 = findOwningRoot(structure, portable, ["go"]);
       const dir = path2.posix.dirname(portable);
       if (owner2?.importPath) {
-        const relative2 = path2.posix.relative(owner2.dir, dir);
-        labels.set(file, relative2 ? `${owner2.importPath}/${relative2}` : owner2.importPath);
+        const relative3 = path2.posix.relative(owner2.dir, dir);
+        labels.set(file, relative3 ? `${owner2.importPath}/${relative3}` : owner2.importPath);
       } else {
         labels.set(file, `go:${path2.posix.relative(structure.projectRoot, dir) || "."}`);
       }
@@ -1111,11 +1957,11 @@ function mapWriterRefRow(row) {
 }
 
 // src/codebase-index/writer-graph-reader.ts
-var MAX_SQL_VARS = 900;
+var MAX_SQL_VARS2 = 900;
 function chunkedIdQuery(stmt, ids, buildSql, extraArgs = []) {
   const results = [];
   let cursor = 0;
-  for (const take of inListChunks(ids.length, MAX_SQL_VARS)) {
+  for (const take of inListChunks(ids.length, MAX_SQL_VARS2)) {
     const chunk = padToInBucket(ids.slice(cursor, cursor + take));
     cursor += take;
     const sql = buildSql(placeholders(chunk.length));
@@ -1123,10 +1969,24 @@ function chunkedIdQuery(stmt, ids, buildSql, extraArgs = []) {
   }
   return results;
 }
+function getSymbolsByIdsWithStatement(stmt, ids) {
+  if (ids.length === 0) return [];
+  return chunkedIdQuery(
+    stmt,
+    ids,
+    (ph) => `SELECT id, name, kind, lang, file, line, signature, scope FROM symbols WHERE id IN (${ph})`
+  );
+}
+function getFileSymbolsWithStatement(stmt, file, limit) {
+  if (limit <= 0) return [];
+  return stmt(
+    "SELECT id, name, kind, line, signature FROM symbols WHERE file = ? ORDER BY line ASC, name ASC LIMIT ?"
+  ).all(file, limit);
+}
 function chunkedIdScalar(stmt, ids, buildSql, extraArgs = []) {
   let total = 0;
   let cursor = 0;
-  for (const take of inListChunks(ids.length, MAX_SQL_VARS)) {
+  for (const take of inListChunks(ids.length, MAX_SQL_VARS2)) {
     const chunk = padToInBucket(ids.slice(cursor, cursor + take));
     cursor += take;
     const sql = buildSql(placeholders(chunk.length));
@@ -1167,7 +2027,7 @@ function resolveSymbolIds(stmt, symbolName, file) {
   if (indexedFiles.length === 0) return [];
   const ids = [];
   let cursor = 0;
-  for (const take of inListChunks(indexedFiles.length, MAX_SQL_VARS)) {
+  for (const take of inListChunks(indexedFiles.length, MAX_SQL_VARS2)) {
     const files = padToInBucket(indexedFiles.slice(cursor, cursor + take));
     cursor += take;
     const rows = stmt(
@@ -1486,7 +2346,9 @@ function getPackageGraphWithStatement(stmt) {
     addWeightedEdge(edgeMap, fromPkg, toPkg, "import", n);
   }
   const edges = materializeWeightedEdges(edgeMap, "pkg");
-  return { nodes: [...pkgNodes.values()], edges };
+  const nodes = [...pkgNodes.values()];
+  decorateGraphNodes(stmt, nodes, packageOf);
+  return { nodes, edges };
 }
 function readPackageLabeller(stmt) {
   const rows = stmt("SELECT file, package FROM files WHERE package != ''").all();
@@ -1569,7 +2431,9 @@ function getFileGraphWithStatement(stmt, packageFilter) {
     addWeightedEdge(edgeMap, fromFile, toFile, "import", n);
   }
   const edges = materializeWeightedEdges(edgeMap, "file");
-  return { nodes: [...fileNodes.values()], edges };
+  const nodes = [...fileNodes.values()];
+  decorateGraphNodes(stmt, nodes, packageOf);
+  return { nodes, edges };
 }
 function getSymbolGraphWithStatement(stmt, fileFilter) {
   const indexedFiles = resolveIndexedFiles(stmt, fileFilter);
@@ -1583,19 +2447,19 @@ function getSymbolGraphWithStatement(stmt, fileFilter) {
   const relatedIds = new Set(syms.map((symbol) => symbol.id));
   const refRows = stmt(
     `SELECT from_id, to_id, call_type, COUNT(*) AS n
-       FROM (
-         SELECT r.from_id, r.to_id, r.to_name, r.call_type, r.line
-         FROM refs r
-         JOIN symbols s ON s.id = r.from_id
-         WHERE s.file IN (${filePlaceholders})
-         UNION
-         SELECT r.from_id, r.to_id, r.to_name, r.call_type, r.line
-         FROM refs r
-         JOIN symbols s ON s.id = r.to_id
-         WHERE s.file IN (${filePlaceholders})
-       )
-       WHERE to_id IS NOT NULL
-       GROUP BY from_id, to_id, call_type`
+         FROM (
+           SELECT r.from_id, r.to_id, r.call_type
+             FROM refs r
+             JOIN symbols s ON s.id = r.from_id
+            WHERE s.file IN (${filePlaceholders})
+            UNION ALL
+           SELECT r.from_id, r.to_id, r.call_type
+             FROM refs r
+             JOIN symbols s ON s.id = r.to_id
+            WHERE s.file IN (${filePlaceholders})
+         )
+         WHERE to_id IS NOT NULL
+         GROUP BY from_id, to_id, call_type`
   ).all(...indexedFiles, ...indexedFiles);
   const edgeMap = /* @__PURE__ */ new Map();
   for (const r of refRows) {
@@ -1615,89 +2479,17 @@ function getSymbolGraphWithStatement(stmt, fileFilter) {
     ).all(...missingIds);
     for (const s of extras) symById.set(s.id, s);
   }
+  const packageOf = readPackageLabeller(stmt);
   const nodes = buildSymbolGraphNodes(
     symById,
     relatedIds,
     new Set(syms.map((symbol) => symbol.file)),
-    readPackageLabeller(stmt)
+    packageOf
   );
+  decorateGraphNodes(stmt, nodes, packageOf);
   return { nodes, edges };
 }
 
-// src/codebase-index/vector-search.ts
-var RRF_K = 60;
-function vectorEmbeddingEnabled() {
-  return process.env["WRONGSTACK_INDEX_VECTORS"] === "1";
-}
-var VECTOR_DIMENSIONS = 384;
-var NGRAM_SIZE = 3;
-function embedText(text) {
-  const vec = new Float32Array(VECTOR_DIMENSIONS);
-  const normalized = text.toLowerCase().trim();
-  if (normalized.length === 0) return vec;
-  const target = normalized.length < NGRAM_SIZE ? ` ${normalized} `.slice(0, Math.max(NGRAM_SIZE, normalized.length + 2)) : normalized;
-  for (let i = 0; i <= target.length - NGRAM_SIZE; i++) {
-    const ngram = target.slice(i, i + NGRAM_SIZE);
-    const bucket = hashNgram(ngram) % VECTOR_DIMENSIONS;
-    vec[bucket] += 1;
-  }
-  let norm = 0;
-  for (let i = 0; i < VECTOR_DIMENSIONS; i++) {
-    norm += vec[i] * vec[i];
-  }
-  norm = Math.sqrt(norm);
-  if (norm > 0) {
-    for (let i = 0; i < VECTOR_DIMENSIONS; i++) {
-      vec[i] /= norm;
-    }
-  }
-  return vec;
-}
-function hashNgram(str) {
-  let hash = 2166136261;
-  for (let i = 0; i < str.length; i++) {
-    hash ^= str.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  const len = Math.min(a.length, b.length);
-  for (let i = 0; i < len; i++) {
-    dot += a[i] * b[i];
-  }
-  return dot;
-}
-function encodeVector(vec) {
-  return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
-}
-function decodeVector(buf) {
-  if (buf.byteLength === 0) return new Float32Array(0);
-  if (buf.byteLength % 4 !== 0) {
-    throw new Error(
-      `decodeVector: invalid vector byteLength ${buf.byteLength} (must be a multiple of 4)`
-    );
-  }
-  const copy = new Float32Array(buf.byteLength / 4);
-  new Uint8Array(copy.buffer).set(buf);
-  return copy;
-}
-function reciprocalRankFusion(bm25Ranks, vectorRanks, k = RRF_K) {
-  const allIds = /* @__PURE__ */ new Set([...bm25Ranks.keys(), ...vectorRanks.keys()]);
-  const scored = [];
-  for (const id of allIds) {
-    const bm25Rank = bm25Ranks.get(id);
-    const vecRank = vectorRanks.get(id);
-    let score = 0;
-    if (bm25Rank !== void 0) score += 1 / (k + bm25Rank);
-    if (vecRank !== void 0) score += 1 / (k + vecRank);
-    scored.push([id, score]);
-  }
-  scored.sort((a, b) => b[1] - a[1]);
-  return scored;
-}
-
 // src/codebase-index/writer-schema.ts
 var METADATA_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS metadata (
@@ -1781,6 +2573,64 @@ var LANG_FAMILY_TABLE_SQL = `
 `;
 var LANG_FAMILY_WILDCARD = "*";
 var SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'trigram')";
+var RANK_TABLES_SQL = `
+  CREATE TABLE IF NOT EXISTS symbol_rank (
+    symbol_id INTEGER PRIMARY KEY,
+    rank REAL NOT NULL,
+    in_deg INTEGER NOT NULL DEFAULT 0,
+    out_deg INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE TABLE IF NOT EXISTS file_rank (
+    file TEXT PRIMARY KEY,
+    rank REAL NOT NULL,
+    in_deg INTEGER NOT NULL DEFAULT 0,
+    out_deg INTEGER NOT NULL DEFAULT 0
+  );
+`;
+var RANK_INDEX_SQL = [
+  // Both tables are read "top N by rank" far more often than by key.
+  "CREATE INDEX IF NOT EXISTS idx_sr_rank ON symbol_rank(rank DESC)",
+  "CREATE INDEX IF NOT EXISTS idx_fr_rank ON file_rank(rank DESC)"
+];
+var CONCEPT_TABLES_SQL = `
+  CREATE TABLE IF NOT EXISTS file_concepts (
+    file TEXT PRIMARY KEY,
+    content_hash TEXT NOT NULL DEFAULT '',
+    summary TEXT NOT NULL DEFAULT '',
+    crux_start INTEGER,
+    crux_end INTEGER,
+    state TEXT NOT NULL DEFAULT 'pending',
+    model TEXT NOT NULL DEFAULT '',
+    updated_at INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE TABLE IF NOT EXISTS subsystems (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    summary TEXT NOT NULL DEFAULT '',
+    member_files TEXT NOT NULL DEFAULT '[]',
+    model TEXT NOT NULL DEFAULT '',
+    updated_at INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE TABLE IF NOT EXISTS concept_edges (
+    from_id TEXT NOT NULL,
+    to_id TEXT NOT NULL,
+    relation TEXT NOT NULL,
+    PRIMARY KEY (from_id, to_id, relation)
+  );
+`;
+var FILE_VECTORS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS file_vectors (
+    file TEXT PRIMARY KEY,
+    vector BLOB NOT NULL,
+    source_hash TEXT NOT NULL DEFAULT '',
+    provider TEXT NOT NULL DEFAULT ''
+  );
+`;
+var CONCEPT_INDEX_SQL = [
+  // The enrichment runner's hot query is "which files still need work".
+  "CREATE INDEX IF NOT EXISTS idx_fc_state ON file_concepts(state)",
+  "CREATE INDEX IF NOT EXISTS idx_ce_from ON concept_edges(from_id)"
+];
 var SYMBOL_VECTORS_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS symbol_vectors (
     symbol_id INTEGER PRIMARY KEY,
@@ -1856,6 +2706,12 @@ function initIndexSchema(db, stmt, getMetadata, setMetadata, maxSqlVars, invalid
       DROP TABLE IF EXISTS files;
       DROP TABLE IF EXISTS refs;
       DROP TABLE IF EXISTS symbol_vectors;
+      DROP TABLE IF EXISTS symbol_rank;
+      DROP TABLE IF EXISTS file_rank;
+      DROP TABLE IF EXISTS file_concepts;
+      DROP TABLE IF EXISTS subsystems;
+      DROP TABLE IF EXISTS concept_edges;
+      DROP TABLE IF EXISTS file_vectors;
     `);
     db.exec("DROP TABLE IF EXISTS symbols_fts");
     stmt("UPDATE metadata SET value = ? WHERE key = ?").run(String(SCHEMA_VERSION), "version");
@@ -1871,6 +2727,11 @@ function initIndexSchema(db, stmt, getMetadata, setMetadata, maxSqlVars, invalid
   for (const sql of REFS_INDEX_SQL) db.exec(sql);
   db.exec(LANG_FAMILY_TABLE_SQL);
   seedLangFamilies(stmt);
+  db.exec(RANK_TABLES_SQL);
+  for (const sql of RANK_INDEX_SQL) db.exec(sql);
+  db.exec(CONCEPT_TABLES_SQL);
+  for (const sql of CONCEPT_INDEX_SQL) db.exec(sql);
+  db.exec(FILE_VECTORS_TABLE_SQL);
   let ftsAvailable = false;
   try {
     const ftsSchema = stmt(
@@ -2205,6 +3066,131 @@ function applyIndexStorePragmas(db) {
   }
 }
 
+// src/codebase-index/writer-rank.ts
+var ROW_PLACEHOLDERS_CACHE2 = /* @__PURE__ */ new Map();
+function getRowPlaceholders2(rowTemplate, count) {
+  const key = `${rowTemplate}\0${count}`;
+  let result = ROW_PLACEHOLDERS_CACHE2.get(key);
+  if (result === void 0) {
+    result = Array.from({ length: count }, () => rowTemplate).join(", ");
+    ROW_PLACEHOLDERS_CACHE2.set(key, result);
+  }
+  return result;
+}
+function replaceSymbolRanksWithStatement(stmt, maxSqlVars, rows) {
+  stmt("DELETE FROM symbol_rank").run();
+  if (rows.length === 0) return;
+  const ladder = ladderChunkSizes(rows.length, Math.max(1, Math.floor(maxSqlVars / 4)));
+  let cursor = 0;
+  for (const take of ladder) {
+    const chunk = rows.slice(cursor, cursor + take);
+    cursor += take;
+    const placeholders2 = getRowPlaceholders2("(?, ?, ?, ?)", chunk.length);
+    const insert = stmt(
+      `INSERT INTO symbol_rank(symbol_id, rank, in_deg, out_deg) VALUES ${placeholders2}`
+    );
+    const binds = [];
+    for (const row of chunk) binds.push(row.symbolId, row.rank, row.inDeg, row.outDeg);
+    insert.run(...binds);
+  }
+}
+function replaceFileRanksWithStatement(stmt, maxSqlVars, rows) {
+  stmt("DELETE FROM file_rank").run();
+  if (rows.length === 0) return;
+  const ladder = ladderChunkSizes(rows.length, Math.max(1, Math.floor(maxSqlVars / 4)));
+  let cursor = 0;
+  for (const take of ladder) {
+    const chunk = rows.slice(cursor, cursor + take);
+    cursor += take;
+    const placeholders2 = getRowPlaceholders2("(?, ?, ?, ?)", chunk.length);
+    const insert = stmt(
+      `INSERT INTO file_rank(file, rank, in_deg, out_deg) VALUES ${placeholders2}`
+    );
+    const binds = [];
+    for (const row of chunk) binds.push(row.file, row.rank, row.inDeg, row.outDeg);
+    insert.run(...binds);
+  }
+}
+function getTopFileRanksWithStatement(stmt, limit) {
+  if (limit <= 0) return [];
+  return stmt(
+    "SELECT file, rank, in_deg AS inDeg, out_deg AS outDeg FROM file_rank ORDER BY rank DESC, file ASC LIMIT ?"
+  ).all(limit);
+}
+function getRankedFilesWithStatement(stmt, limit) {
+  if (limit <= 0) return [];
+  return stmt(`
+    SELECT fr.file AS file, fr.rank AS rank, fr.in_deg AS inDeg, fr.out_deg AS outDeg,
+           f.package AS package, f.lang AS lang, f.symbol_count AS symbolCount
+    FROM file_rank fr
+    JOIN files f ON f.file = fr.file
+    ORDER BY fr.rank DESC, fr.file ASC
+    LIMIT ?
+  `).all(limit);
+}
+function getPackageFileCountsWithStatement(stmt) {
+  const rows = stmt("SELECT package, COUNT(*) AS n FROM files GROUP BY package").all();
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) map.set(row.package, row.n);
+  return map;
+}
+function getTopSymbolRanksWithStatement(stmt, limit) {
+  if (limit <= 0) return [];
+  return stmt(
+    "SELECT symbol_id AS symbolId, rank, in_deg AS inDeg, out_deg AS outDeg FROM symbol_rank ORDER BY rank DESC, symbol_id ASC LIMIT ?"
+  ).all(limit);
+}
+function getSymbolNameCandidatesWithStatement(stmt) {
+  const rows = stmt(`
+    SELECT s.id AS symbolId, g.c AS candidates
+    FROM symbols s
+    JOIN lang_family lf ON lf.lang = s.lang
+    JOIN (
+      SELECT s2.name AS name, lf2.family AS family, COUNT(*) AS c
+      FROM symbols s2
+      JOIN lang_family lf2 ON lf2.lang = s2.lang
+      GROUP BY s2.name, lf2.family
+      HAVING COUNT(*) > 1
+    ) g ON g.name = s.name AND g.family = lf.family
+  `).all();
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) map.set(row.symbolId, row.candidates);
+  return map;
+}
+function getImportVisibilityWithStatement(stmt) {
+  const rows = stmt(`
+    SELECT DISTINCT s.file AS src, r.to_file AS dst
+    FROM refs r
+    JOIN symbols s ON s.id = r.from_id
+    WHERE r.call_type = 'import' AND r.to_file IS NOT NULL AND r.to_file <> ''
+  `).all();
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let targets = map.get(row.src);
+    if (targets === void 0) {
+      targets = /* @__PURE__ */ new Set();
+      map.set(row.src, targets);
+    }
+    targets.add(row.dst);
+  }
+  return map;
+}
+function getFileRankMapWithStatement(stmt) {
+  const rows = stmt("SELECT file, rank FROM file_rank").all();
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) map.set(row.file, row.rank);
+  return map;
+}
+function getRankCountsWithStatement(stmt) {
+  const symbols = Number(
+    stmt("SELECT COUNT(*) AS n FROM symbol_rank").get()?.n ?? 0
+  );
+  const files = Number(
+    stmt("SELECT COUNT(*) AS n FROM file_rank").get()?.n ?? 0
+  );
+  return { symbols, files };
+}
+
 // src/codebase-index/writer-refs.ts
 var FAMILY_MATCH_SQL = `(
   sym.lang = refs.lang
@@ -2744,11 +3730,11 @@ var IndexStore = class _IndexStore {
   bm25Cache = null;
   bm25Dirty = true;
   stmt(sql) {
-    const cached = this.stmtCache.get(sql);
-    if (cached !== void 0) {
+    const cached2 = this.stmtCache.get(sql);
+    if (cached2 !== void 0) {
       this.stmtCache.delete(sql);
-      this.stmtCache.set(sql, cached);
-      return cached;
+      this.stmtCache.set(sql, cached2);
+      return cached2;
     }
     const s = this.db.prepare(sql);
     this.stmtCache.set(sql, s);
@@ -3036,6 +4022,12 @@ var IndexStore = class _IndexStore {
         this.db.exec("DROP TABLE IF EXISTS metadata");
         if (this.ftsAvailable) this.db.exec("DROP TABLE IF EXISTS symbols_fts");
         this.db.exec("DROP TABLE IF EXISTS symbol_vectors");
+        this.db.exec("DROP TABLE IF EXISTS symbol_rank");
+        this.db.exec("DROP TABLE IF EXISTS file_rank");
+        this.db.exec("DROP TABLE IF EXISTS file_concepts");
+        this.db.exec("DROP TABLE IF EXISTS subsystems");
+        this.db.exec("DROP TABLE IF EXISTS concept_edges");
+        this.db.exec("DROP TABLE IF EXISTS file_vectors");
         this.stmtCache.clear();
         this.initSchema();
         this.stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES (?, ?)").run(
@@ -3262,9 +4254,151 @@ var IndexStore = class _IndexStore {
   getAllSymbols() {
     return this.stmt("SELECT id, name, file, kind, line FROM symbols ORDER BY id").all().map((r) => ({ ...r, kind: r.kind }));
   }
+  /** Declarations in one file, in source order. */
+  getFileSymbols(file, limit) {
+    return getFileSymbolsWithStatement((sql) => this.stmt(sql), file, limit);
+  }
+  /** Declarations behind an arbitrary id list, for the retrieval walk. */
+  getSymbolsByIds(ids) {
+    return getSymbolsByIdsWithStatement((sql) => this.stmt(sql), ids);
+  }
   getAllResolvedRefs() {
     return getAllResolvedRefsWithStatement((sql) => this.stmt(sql));
   }
+  /**
+   * Replace both rank tables in one write. Called once per index run, after
+   * ref resolution has settled — a rank computed against half-resolved refs
+   * would describe a graph that never existed.
+   */
+  replaceRanks(symbols, files) {
+    this.runWithRetry(() => {
+      const ownsTransaction = this.beginWriteTransaction();
+      try {
+        replaceSymbolRanksWithStatement((sql) => this.stmt(sql), _IndexStore.MAX_SQL_VARS, symbols);
+        replaceFileRanksWithStatement((sql) => this.stmt(sql), _IndexStore.MAX_SQL_VARS, files);
+        this.commitWriteTransaction(ownsTransaction);
+      } catch (err) {
+        this.rollbackWriteTransaction(ownsTransaction);
+        throw err;
+      }
+    });
+  }
+  // ── Semantic file vectors ────────────────────────────────────────────────
+  /** Wipe stored vectors when the embedding model changed. */
+  reconcileVectorProvider(provider) {
+    return this.runWithRetry(
+      () => reconcileVectorProviderWithStatement(
+        (sql) => this.stmt(sql),
+        (key) => this.getMetadata(key),
+        (key, value) => this.setMetadata(key, value),
+        provider
+      )
+    );
+  }
+  getFileVectorStates(provider) {
+    return getFileVectorStatesWithStatement((sql) => this.stmt(sql), provider);
+  }
+  upsertFileVectors(rows) {
+    this.runWithRetry(() => {
+      const ownsTransaction = this.beginWriteTransaction();
+      try {
+        upsertFileVectorsWithStatement((sql) => this.stmt(sql), _IndexStore.MAX_SQL_VARS, rows);
+        this.commitWriteTransaction(ownsTransaction);
+      } catch (err) {
+        this.rollbackWriteTransaction(ownsTransaction);
+        throw err;
+      }
+    });
+  }
+  pruneOrphanFileVectors() {
+    return this.runWithRetry(() => pruneOrphanFileVectorsWithStatement((sql) => this.stmt(sql)));
+  }
+  countFileVectors() {
+    return countFileVectorsWithStatement((sql) => this.stmt(sql));
+  }
+  searchFileVectors(query, limit, minScore) {
+    return searchFileVectorsWithStatement((sql) => this.stmt(sql), query, limit, minScore);
+  }
+  // ── Concept layer ────────────────────────────────────────────────────────
+  upsertFileConcept(concept) {
+    this.runWithRetry(() => {
+      const ownsTransaction = this.beginWriteTransaction();
+      try {
+        upsertFileConceptWithStatement((sql) => this.stmt(sql), concept);
+        this.commitWriteTransaction(ownsTransaction);
+      } catch (err) {
+        this.rollbackWriteTransaction(ownsTransaction);
+        throw err;
+      }
+    });
+  }
+  getFileConcept(file) {
+    return getFileConceptWithStatement((sql) => this.stmt(sql), file);
+  }
+  getAllFileConcepts() {
+    return getAllFileConceptsWithStatement((sql) => this.stmt(sql));
+  }
+  getReadyConceptSummaries() {
+    return getReadyConceptSummariesWithStatement((sql) => this.stmt(sql));
+  }
+  getConceptCoverage() {
+    return getConceptCoverageWithStatement((sql) => this.stmt(sql));
+  }
+  /** Flag summaries whose file has changed since they were written. */
+  markStaleConcepts() {
+    return this.runWithRetry(() => markStaleConceptsWithStatement((sql) => this.stmt(sql)));
+  }
+  /** Drop summaries for files that are no longer indexed. */
+  pruneOrphanConcepts() {
+    return this.runWithRetry(() => pruneOrphanConceptsWithStatement((sql) => this.stmt(sql)));
+  }
+  replaceSubsystems(subsystems, edges) {
+    this.runWithRetry(() => {
+      const ownsTransaction = this.beginWriteTransaction();
+      try {
+        replaceSubsystemsWithStatement(
+          (sql) => this.stmt(sql),
+          _IndexStore.MAX_SQL_VARS,
+          subsystems,
+          edges
+        );
+        this.commitWriteTransaction(ownsTransaction);
+      } catch (err) {
+        this.rollbackWriteTransaction(ownsTransaction);
+        throw err;
+      }
+    });
+  }
+  getSubsystems() {
+    return getSubsystemsWithStatement((sql) => this.stmt(sql));
+  }
+  getConceptEdges() {
+    return getConceptEdgesWithStatement((sql) => this.stmt(sql));
+  }
+  getPackageFileCounts() {
+    return getPackageFileCountsWithStatement((sql) => this.stmt(sql));
+  }
+  getRankedFiles(limit) {
+    return getRankedFilesWithStatement((sql) => this.stmt(sql), limit);
+  }
+  getTopFileRanks(limit) {
+    return getTopFileRanksWithStatement((sql) => this.stmt(sql), limit);
+  }
+  getTopSymbolRanks(limit) {
+    return getTopSymbolRanksWithStatement((sql) => this.stmt(sql), limit);
+  }
+  getFileRankMap() {
+    return getFileRankMapWithStatement((sql) => this.stmt(sql));
+  }
+  getRankCounts() {
+    return getRankCountsWithStatement((sql) => this.stmt(sql));
+  }
+  getSymbolNameCandidates() {
+    return getSymbolNameCandidatesWithStatement((sql) => this.stmt(sql));
+  }
+  getImportVisibility() {
+    return getImportVisibilityWithStatement((sql) => this.stmt(sql));
+  }
   getAllImportRefs() {
     return getAllImportRefsWithStatement((sql) => this.stmt(sql));
   }
@@ -3636,11 +4770,11 @@ var ModuleResolver = class {
   }
   /** `#include "foo/bar.h"` — quoted form only; `<…>` is a system header. */
   resolveInclude(fromFile, spec) {
-    const relative2 = this.lookupWithExtensions(
+    const relative3 = this.lookupWithExtensions(
       path4.posix.join(path4.posix.dirname(fromFile), spec),
       "c"
     );
-    if (relative2) return relative2;
+    if (relative3) return relative3;
     for (const base of [
       path4.posix.join(this.structure.projectRoot, "include"),
       this.structure.projectRoot
@@ -3652,11 +4786,11 @@ var ModuleResolver = class {
   }
   /** `require_relative 'x'` is relative; `require 'x'` is looked up under lib/. */
   resolveRuby(fromFile, spec) {
-    const relative2 = this.lookupWithExtensions(
+    const relative3 = this.lookupWithExtensions(
       path4.posix.join(path4.posix.dirname(fromFile), spec),
       "ruby"
     );
-    if (relative2) return relative2;
+    if (relative3) return relative3;
     for (const base of [
       path4.posix.join(this.structure.projectRoot, "lib"),
       this.structure.projectRoot
@@ -3859,7 +4993,7 @@ var ParserWorkerPool = class {
    */
   async reparseInline(batch, orphaned, workerId) {
     try {
-      const { parseFileContent } = await import("./parser-dispatch-BDVCJXTV.js");
+      const { parseFileContent } = await import("./parser-dispatch-UQAB4E6V.js");
       for (const item of orphaned) {
         if (batch.settled) return;
         try {
@@ -3952,6 +5086,10 @@ function isAbortError(err) {
 }
 var DEFAULT_IGNORE = DEFAULT_WALK_IGNORE_DIRS;
 var DEFAULT_IGNORE_FILES = /* @__PURE__ */ new Set(["package-lock.json", "pnpm-lock.yaml", "pnpm-lock.yml"]);
+var ATLAS_PROJECTION_PREFIX = ".wrongstack/atlas/";
+function isAtlasProjection(relativePosixPath) {
+  return relativePosixPath.startsWith(ATLAS_PROJECTION_PREFIX);
+}
 var INDEXABLE_EXTENSION_SET = new Set(INDEXABLE_EXTENSIONS);
 var MAX_INDEX_FILE_BYTES = 5 * 1024 * 1024;
 var MAX_GIT_FILE_LIST_BYTES = 64 * 1024 * 1024;
@@ -4023,15 +5161,15 @@ async function findGitSourceFiles(projectRoot, ignore, signal) {
       }
     }
     const files = [];
-    for (const relative2 of output.toString("utf8").split("\0")) {
-      if (!relative2) continue;
-      const portable = relative2.replace(/\\/g, "/");
-      if (portable.split("/").some((segment) => ignoreSet.has(segment)) || DEFAULT_IGNORE_FILES.has(path5.posix.basename(portable))) {
+    for (const relative3 of output.toString("utf8").split("\0")) {
+      if (!relative3) continue;
+      const portable = relative3.replace(/\\/g, "/");
+      if (portable.split("/").some((segment) => ignoreSet.has(segment)) || DEFAULT_IGNORE_FILES.has(path5.posix.basename(portable)) || isAtlasProjection(portable)) {
         continue;
       }
-      const full = path5.resolve(projectRoot, relative2);
+      const full = path5.resolve(projectRoot, relative3);
       if (deleted.has(full)) continue;
-      const ext = path5.extname(relative2).toLowerCase();
+      const ext = path5.extname(relative3).toLowerCase();
       if (INDEXABLE_EXTENSION_SET.has(ext) || detectLang(full) !== null) files.push(full);
     }
     const snapshot = createHash("sha256").update(stagedOutput).update("\0").update(statusOutput);
@@ -4091,6 +5229,7 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
         await walk(full);
       } else if (e.isFile()) {
         if (DEFAULT_IGNORE_FILES.has(e.name) || isGitIgnored(rel, false)) continue;
+        if (isAtlasProjection(rel)) continue;
         const ext = path5.extname(e.name).toLowerCase();
         if (indexableExts.has(ext) || detectLang(full) !== null) {
           results.push(full);
@@ -4191,7 +5330,7 @@ async function runIndexerAtomic(store, opts) {
     files = opts.files.map((f) => path5.resolve(projectRoot, f)).filter((f) => {
       if (!isWithinProject(projectRoot, f)) return false;
       const rel = path5.relative(projectRoot, f).replace(/\\/g, "/");
-      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path5.basename(f)) && !isGitIgnored(rel, false);
+      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path5.basename(f)) && !isAtlasProjection(rel) && !isGitIgnored(rel, false);
     });
   } else {
     const discovery = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
@@ -4280,6 +5419,7 @@ async function runIndexerAtomic(store, opts) {
           let content;
           try {
             content = await fs5.readFile(file, { encoding: "utf8", signal });
+            recordFilesystemRead(Buffer.byteLength(content, "utf8"));
           } catch (e) {
             if (isAbortError(e)) throw e;
             return {
@@ -4499,6 +5639,9 @@ async function runIndexerAtomic(store, opts) {
   });
   store.setMetadata("ref_resolution_version", refResolutionVersion);
   store.setMetadata("relation_graph_version", relationGraphVersion);
+  if (shouldRefreshRanks(store, { files: opts.files, force })) {
+    runGraphRankPass(store, errors);
+  }
   const completeProjectScope = !opts.files && (!langs || langs.length === 0) && (!opts.ignore || opts.ignore.length === 0);
   if (completeProjectScope && discoverySnapshotKey !== void 0) {
     const finalSnapshot = await findGitSourceFiles(projectRoot, ignore, signal);
@@ -4528,6 +5671,7 @@ async function runIndexerAtomic(store, opts) {
 }
 
 // src/codebase-index/index-service.ts
+import * as path6 from "node:path";
 async function indexService(args, hooks = {}) {
   const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
@@ -4566,6 +5710,43 @@ function searchService(args) {
     indexStorePool.release(store);
   }
 }
+function contextService(args) {
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
+  try {
+    return retrieveContext(
+      store,
+      args.projectRoot,
+      args.indexDir,
+      {
+        query: args.query,
+        vectorFiles: args.vectorFiles,
+        limit: args.limit,
+        symbolsPerFile: args.symbolsPerFile,
+        pathPrefix: args.pathPrefix
+      },
+      (file) => {
+        const relative3 = path6.relative(args.projectRoot, file);
+        if (!relative3 || relative3.startsWith("..")) return posixIndexPath(file);
+        return posixIndexPath(relative3);
+      }
+    );
+  } finally {
+    indexStorePool.release(store);
+  }
+}
+function vectorSearchService(args) {
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
+  try {
+    const total = store.countFileVectors();
+    if (total === 0) return { hits: [], total };
+    return {
+      hits: store.searchFileVectors(Float32Array.from(args.vector), args.limit, args.minScore ?? 0),
+      total
+    };
+  } finally {
+    indexStorePool.release(store);
+  }
+}
 function statsService(args) {
   const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
@@ -4628,19 +5809,46 @@ export {
   IndexCircuitBreaker,
   indexCircuitBreaker,
   resetIndexCircuitBreaker,
+  DEFAULT_RESTART,
+  DEFAULT_ITERATIONS,
+  UNVERIFIED_VISIBILITY_WEIGHT,
+  CONTRADICTED_VISIBILITY_WEIGHT,
+  buildWiringGraph,
+  pageRank,
+  toSymbolRankRows,
+  aggregateFileRank,
+  getWiringSnapshot,
+  clearWiringSnapshot,
+  posixIndexPath,
+  resolveIndexDir,
+  codebaseIndexDirOverride,
+  SEED_LIMIT,
+  DEFAULT_LIMIT,
+  DEFAULT_SYMBOLS_PER_FILE,
+  retrieveContext,
+  xxhash64String,
+  RANK_VERSION,
+  RANK_VERSION_KEY,
+  RANK_REFRESH_FILE_THRESHOLD,
+  shouldRefreshRanks,
+  runGraphRankPass,
   tokenise,
   buildIndexableText,
   buildBm25Index,
   SCHEMA_VERSION,
-  resolveIndexDir,
-  codebaseIndexDirOverride,
+  CONCEPT_RELATIONS,
+  isConceptRelation,
+  decorateGraphNodes,
   lspKindToInternalKind,
   internalKindToLspKind,
+  FILE_VECTOR_PROVIDER_KEY,
   IndexStore,
   indexStorePool,
   runIndexer,
   indexService,
   searchService,
+  contextService,
+  vectorSearchService,
   statsService,
   packageGraphService,
   fileGraphService,
@@ -4648,4 +5856,4 @@ export {
   incomingCallsService,
   outgoingCallsService
 };
-//# sourceMappingURL=chunk-N3K2SFEI.js.map
+//# sourceMappingURL=chunk-3JVSOBHU.js.map