@pratik7368patil/anchor-core 0.1.30 → 0.1.32

package/dist/index.js

@@ -175,8 +175,11 @@ function canonicalizeText(text) {
   return text.toLowerCase().replace(/https?:\/\/\S+/g, "").replace(/[^a-z0-9_./ -]/g, " ").replace(/\s+/g, " ").trim();
 }
 function tokenizeSearchText(text, maxTokens = 32) {
-  const tokens = text.toLowerCase().match(/[a-z0-9_./-]{3,}/g);
-  return uniqueStrings(tokens ?? []).slice(0, maxTokens);
+  const shortSignalTokens = /* @__PURE__ */ new Set(["id", "db", "api", "key", "sql", "jwt", "ui", "ux"]);
+  const tokens = text.toLowerCase().match(/[a-z0-9_./-]{2,}/g);
+  return uniqueStrings(
+    (tokens ?? []).filter((token) => token.length >= 3 || shortSignalTokens.has(token))
+  ).slice(0, maxTokens);
 }
 
 // src/security/redact-secrets.ts
@@ -379,7 +382,8 @@ CREATE TABLE IF NOT EXISTS code_index_state (
   last_indexed_at TEXT NOT NULL,
   indexed_files INTEGER NOT NULL,
   code_chunks INTEGER NOT NULL,
-  skipped_files INTEGER NOT NULL
+  skipped_files INTEGER NOT NULL,
+  last_indexed_commit TEXT
 );
 
 CREATE TABLE IF NOT EXISTS code_imports (
@@ -1757,6 +1761,14 @@ function applyPerformancePragmas(db) {
   db.pragma("mmap_size = 268435456");
   db.pragma("temp_store = MEMORY");
 }
+function runDatabaseMaintenance(db) {
+  try {
+    db.exec("ANALYZE");
+    db.pragma("optimize");
+    db.pragma("wal_checkpoint(TRUNCATE)");
+  } catch {
+  }
+}
 function initializeSchema(db) {
   db.exec(SCHEMA_SQL);
   ensureColumn(db, "sync_state", "history_coverage", "TEXT");
@@ -1770,6 +1782,7 @@ function initializeSchema(db) {
   ensureColumn(db, "sync_state", "graphql_cursor_reset_at", "TEXT");
   ensureColumn(db, "sync_state", "graphql_cursor_reason", "TEXT");
   ensureColumn(db, "sync_state", "graphql_cursor_updated_at", "TEXT");
+  ensureColumn(db, "code_index_state", "last_indexed_commit", "TEXT");
 }
 function ensureColumn(db, tableName, columnName, definition) {
   const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
@@ -1819,10 +1832,153 @@ function ensureRepository(db, fullName) {
   if (!row) throw new Error(`Failed to create repository row for ${fullName}`);
   return row.id;
 }
+function getRepositoryId(db, fullName) {
+  const row = db.prepare("SELECT id FROM repositories WHERE full_name = ?").get(fullName);
+  return row?.id;
+}
 function getLastSyncTime(db, repo) {
   const row = db.prepare("SELECT last_sync_at FROM sync_state WHERE repo = ?").get(repo);
   return row?.last_sync_at ?? void 0;
 }
+function getCodeIndexStateForRepo(db, repo) {
+  initializeSchema(db);
+  const row = db.prepare(
+    `SELECT repo, last_indexed_at, indexed_files, code_chunks, skipped_files, last_indexed_commit
+       FROM code_index_state
+       WHERE repo = ?`
+  ).get(repo);
+  if (!row?.repo) return void 0;
+  return {
+    repo: row.repo,
+    lastIndexedAt: row.last_indexed_at ?? void 0,
+    indexedFiles: row.indexed_files ?? 0,
+    codeChunks: row.code_chunks ?? 0,
+    skippedFiles: row.skipped_files ?? 0,
+    lastIndexedCommit: row.last_indexed_commit ?? void 0
+  };
+}
+function getRepoCodeFileHashes(db, repo) {
+  initializeSchema(db);
+  const repoId = getRepositoryId(db, repo);
+  if (!repoId) return /* @__PURE__ */ new Map();
+  const rows = db.prepare("SELECT path, content_hash FROM code_files WHERE repo_id = ?").all(repoId);
+  return new Map(rows.map((row) => [row.path, row.content_hash]));
+}
+function getRepoCodeFiles(db, repo) {
+  initializeSchema(db);
+  const repoId = getRepositoryId(db, repo);
+  if (!repoId) return [];
+  const rows = db.prepare(
+    `SELECT path, language, size_bytes, content_hash, updated_at
+       FROM code_files
+       WHERE repo_id = ?`
+  ).all(repoId);
+  return rows.map((row) => ({
+    repo,
+    path: row.path,
+    language: row.language ?? void 0,
+    sizeBytes: row.size_bytes,
+    contentHash: row.content_hash,
+    updatedAt: row.updated_at
+  }));
+}
+function parseJsonArray3(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function getRepoCodeChunkSymbols(db, repo) {
+  initializeSchema(db);
+  const repoId = getRepositoryId(db, repo);
+  if (!repoId) return [];
+  const rows = db.prepare(
+    `SELECT id, file_path, language, start_line, end_line, symbols_json, content_hash, updated_at
+       FROM code_chunks
+       WHERE repo_id = ?`
+  ).all(repoId);
+  return rows.map((row) => ({
+    id: row.id,
+    repo,
+    filePath: row.file_path,
+    language: row.language ?? void 0,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    sanitizedText: "",
+    symbols: parseJsonArray3(row.symbols_json),
+    contentHash: row.content_hash,
+    updatedAt: row.updated_at
+  }));
+}
+function getRepoTestChunks(db, repo) {
+  initializeSchema(db);
+  const repoId = getRepositoryId(db, repo);
+  if (!repoId) return [];
+  const rows = db.prepare(
+    `SELECT id, file_path, language, start_line, end_line, sanitized_text, symbols_json, content_hash, updated_at
+       FROM code_chunks
+       WHERE repo_id = ? AND file_path IN (
+         SELECT path FROM test_files WHERE repo_id = ?
+       )`
+  ).all(repoId, repoId);
+  return rows.map((row) => ({
+    id: row.id,
+    repo,
+    filePath: row.file_path,
+    language: row.language ?? void 0,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    sanitizedText: row.sanitized_text,
+    symbols: parseJsonArray3(row.symbols_json),
+    contentHash: row.content_hash,
+    updatedAt: row.updated_at
+  }));
+}
+function getRepoCodeImports(db, repo) {
+  initializeSchema(db);
+  const repoId = getRepositoryId(db, repo);
+  if (!repoId) return [];
+  const rows = db.prepare(
+    `SELECT source_path, specifier, imported_path, imported_symbols_json, kind
+       FROM code_imports
+       WHERE repo_id = ?`
+  ).all(repoId);
+  return rows.map((row) => ({
+    repo,
+    sourcePath: row.source_path,
+    specifier: row.specifier,
+    importedPath: row.imported_path ?? void 0,
+    importedSymbols: parseJsonArray3(row.imported_symbols_json),
+    kind: row.kind
+  }));
+}
+function getRepoCodeCounts(db, repo) {
+  initializeSchema(db);
+  const repoId = getRepositoryId(db, repo);
+  if (!repoId) return { files: 0, chunks: 0 };
+  const files = db.prepare("SELECT COUNT(*) AS count FROM code_files WHERE repo_id = ?").get(repoId).count;
+  const chunks = db.prepare("SELECT COUNT(*) AS count FROM code_chunks WHERE repo_id = ?").get(repoId).count;
+  return { files, chunks };
+}
+function touchCodeIndexState(db, repo, skippedFiles, currentCommit2) {
+  initializeSchema(db);
+  const counts = getRepoCodeCounts(db, repo);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT INTO code_index_state
+     (repo, last_indexed_at, indexed_files, code_chunks, skipped_files, last_indexed_commit)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(repo) DO UPDATE SET
+       last_indexed_at = excluded.last_indexed_at,
+       indexed_files = excluded.indexed_files,
+       code_chunks = excluded.code_chunks,
+       skipped_files = excluded.skipped_files,
+       last_indexed_commit = excluded.last_indexed_commit`
+  ).run(repo, now, counts.files, counts.chunks, skippedFiles, currentCommit2 ?? null);
+  return counts;
+}
 function updateSyncState(db, repo, lastIndexedPr, metadata = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.prepare(
@@ -2115,13 +2271,24 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
   initializeSchema(db);
   const repoId = ensureRepository(db, repo);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  options.onProgress?.({ stage: "writing_code_index", repo, phase: "Inferring test awareness" });
-  const testAwareness = inferTestAwareness(repo, codeFiles, codeChunks, {
+  const deletedPaths = options.deletedPaths ?? [];
+  const changedImports = options.changedImports;
+  const testAwareness = options.testAwareness ?? inferTestAwareness(repo, codeFiles, codeChunks, {
     onProgress: options.onProgress
   });
   options.onProgress?.({ stage: "writing_code_index", repo, phase: "Writing code index" });
+  const changedPaths = [...new Set(codeFiles.map((file) => file.path))];
+  const affectedPaths = [.../* @__PURE__ */ new Set([...changedPaths, ...deletedPaths])];
   const transaction = db.transaction(() => {
-    const existingChunkRowIds = db.prepare("SELECT rowid FROM code_chunks WHERE repo_id = ?").all(repoId);
+    let existingChunkRowIds = [];
+    if (affectedPaths.length > 0) {
+      const placeholders = affectedPaths.map(() => "?").join(", ");
+      existingChunkRowIds = db.prepare(
+        `SELECT rowid
+           FROM code_chunks
+           WHERE repo_id = ? AND file_path IN (${placeholders})`
+      ).all(repoId, ...affectedPaths);
+    }
     const existingPatternRowIds = db.prepare("SELECT rowid FROM architecture_patterns WHERE repo_id = ?").all(repoId);
     options.onProgress?.({
       stage: "deleting_existing_code_index",
@@ -2141,11 +2308,51 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
         chunks: existingChunkRowIds.length
       })
     );
-    db.prepare("DELETE FROM code_chunks WHERE repo_id = ?").run(repoId);
-    db.prepare("DELETE FROM code_files WHERE repo_id = ?").run(repoId);
-    db.prepare("DELETE FROM test_links WHERE repo_id = ? AND reason != 'PR co-change'").run(repoId);
-    db.prepare("DELETE FROM test_files WHERE repo_id = ?").run(repoId);
+    if (affectedPaths.length > 0) {
+      const placeholders = affectedPaths.map(() => "?").join(", ");
+      db.prepare(
+        `DELETE FROM code_chunks
+         WHERE repo_id = ? AND file_path IN (${placeholders})`
+      ).run(repoId, ...affectedPaths);
+      db.prepare(
+        `DELETE FROM code_files
+         WHERE repo_id = ? AND path IN (${placeholders})`
+      ).run(repoId, ...affectedPaths);
+      db.prepare(
+        `DELETE FROM test_links
+         WHERE repo_id = ?
+           AND reason != 'PR co-change'
+           AND (source_path IN (${placeholders}) OR test_path IN (${placeholders}))`
+      ).run(repoId, ...affectedPaths, ...affectedPaths);
+      db.prepare(
+        `DELETE FROM test_files
+         WHERE repo_id = ? AND path IN (${placeholders})`
+      ).run(repoId, ...affectedPaths);
+      if (changedImports) {
+        db.prepare(
+          `DELETE FROM code_imports
+           WHERE repo_id = ? AND source_path IN (${placeholders})`
+        ).run(repoId, ...affectedPaths);
+      }
+    }
     deleteExistingArchitectureData(db, repoId, repo, existingPatternRowIds, options);
+    if (changedImports) {
+      const insertImport = db.prepare(
+        `INSERT INTO code_imports
+         (repo_id, source_path, specifier, imported_path, imported_symbols_json, kind)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      );
+      for (const item of changedImports) {
+        insertImport.run(
+          repoId,
+          item.sourcePath,
+          item.specifier,
+          item.importedPath ?? null,
+          JSON.stringify(item.importedSymbols),
+          item.kind
+        );
+      }
+    }
     const insertFile = db.prepare(
       `INSERT INTO code_files
        (repo_id, path, language, size_bytes, content_hash, updated_at)
@@ -2237,18 +2444,22 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
       }
     }
     insertTestAwareness(db, repoId, repo, testAwareness.testFiles, testAwareness.testLinks, options);
-    insertArchitectureData(db, repoId, repo, architecture, options);
+    insertArchitectureData(db, repoId, repo, architecture, options, !changedImports);
     insertArchitectureMapEdges(db, repoId, repo, architecture, testAwareness.testLinks, options);
     options.onProgress?.({ stage: "writing_code_index", repo, phase: "Updating index state" });
+    const totalFileCount = db.prepare("SELECT COUNT(*) AS count FROM code_files WHERE repo_id = ?").get(repoId).count;
+    const totalChunkCount = db.prepare("SELECT COUNT(*) AS count FROM code_chunks WHERE repo_id = ?").get(repoId).count;
     db.prepare(
-      `INSERT INTO code_index_state (repo, last_indexed_at, indexed_files, code_chunks, skipped_files)
-       VALUES (?, ?, ?, ?, ?)
+      `INSERT INTO code_index_state
+       (repo, last_indexed_at, indexed_files, code_chunks, skipped_files, last_indexed_commit)
+       VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT(repo) DO UPDATE SET
          last_indexed_at = excluded.last_indexed_at,
          indexed_files = excluded.indexed_files,
          code_chunks = excluded.code_chunks,
-         skipped_files = excluded.skipped_files`
-    ).run(repo, now, codeFiles.length, codeChunks.length, skippedFiles);
+         skipped_files = excluded.skipped_files,
+         last_indexed_commit = excluded.last_indexed_commit`
+    ).run(repo, now, totalFileCount, totalChunkCount, skippedFiles, options.currentCommit ?? null);
     db.prepare(
       `INSERT INTO architecture_index_state (repo, last_indexed_at, components, patterns, imports)
        VALUES (?, ?, ?, ?, ?)
@@ -2266,9 +2477,10 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
     );
   });
   transaction();
+  const counts = getRepoCodeCounts(db, repo);
   return {
-    indexedFiles: codeFiles.length,
-    codeChunksCreated: codeChunks.length,
+    indexedFiles: counts.files,
+    codeChunksCreated: counts.chunks,
     testFilesIndexed: testAwareness.testFiles.length,
     testLinksCreated: testAwareness.testLinks.length,
     architectureComponentsIndexed: architecture.components.length,
@@ -2293,40 +2505,41 @@ function deleteExistingArchitectureData(db, repoId, repo, patternRowIds, options
   );
   db.prepare("DELETE FROM architecture_patterns WHERE repo_id = ?").run(repoId);
   db.prepare("DELETE FROM architecture_components WHERE repo_id = ?").run(repoId);
-  db.prepare("DELETE FROM code_imports WHERE repo_id = ?").run(repoId);
   db.prepare("DELETE FROM architecture_map_edges WHERE repo_id = ?").run(repoId);
 }
-function insertArchitectureData(db, repoId, repo, architecture, options = {}) {
-  const insertImport = db.prepare(
-    `INSERT INTO code_imports
-     (repo_id, source_path, specifier, imported_path, imported_symbols_json, kind)
-     VALUES (?, ?, ?, ?, ?, ?)`
-  );
-  options.onProgress?.({
-    stage: "writing_architecture_data",
-    repo,
-    current: 0,
-    total: architecture.imports.length,
-    kind: "imports"
-  });
-  for (const [index, item] of architecture.imports.entries()) {
-    insertImport.run(
-      repoId,
-      item.sourcePath,
-      item.specifier,
-      item.importedPath ?? null,
-      JSON.stringify(item.importedSymbols),
-      item.kind
+function insertArchitectureData(db, repoId, repo, architecture, options = {}, includeImports = true) {
+  if (includeImports) {
+    const insertImport = db.prepare(
+      `INSERT INTO code_imports
+       (repo_id, source_path, specifier, imported_path, imported_symbols_json, kind)
+       VALUES (?, ?, ?, ?, ?, ?)`
     );
-    const current = index + 1;
-    if (shouldEmitCodeWriteProgress(current, architecture.imports.length)) {
-      options.onProgress?.({
-        stage: "writing_architecture_data",
-        repo,
-        current,
-        total: architecture.imports.length,
-        kind: "imports"
-      });
+    options.onProgress?.({
+      stage: "writing_architecture_data",
+      repo,
+      current: 0,
+      total: architecture.imports.length,
+      kind: "imports"
+    });
+    for (const [index, item] of architecture.imports.entries()) {
+      insertImport.run(
+        repoId,
+        item.sourcePath,
+        item.specifier,
+        item.importedPath ?? null,
+        JSON.stringify(item.importedSymbols),
+        item.kind
+      );
+      const current = index + 1;
+      if (shouldEmitCodeWriteProgress(current, architecture.imports.length)) {
+        options.onProgress?.({
+          stage: "writing_architecture_data",
+          repo,
+          current,
+          total: architecture.imports.length,
+          kind: "imports"
+        });
+      }
     }
   }
   const insertComponent = db.prepare(
@@ -2482,19 +2695,36 @@ function insertPrCochangeTestLinks(db, repoId, filePaths) {
   }
 }
 function insertTestAwareness(db, repoId, repo, testFiles, testLinks, options = {}) {
+  const dedupedTestFilesByPath = /* @__PURE__ */ new Map();
+  for (const file of testFiles) dedupedTestFilesByPath.set(file.path, file);
+  const dedupedTestFiles = [...dedupedTestFilesByPath.values()];
+  const dedupedTestLinksByKey = /* @__PURE__ */ new Map();
+  for (const link of testLinks) {
+    const key = `${link.sourcePath}\0${link.testPath}\0${link.reason}`;
+    const existing = dedupedTestLinksByKey.get(key);
+    if (!existing || link.strength > existing.strength) {
+      dedupedTestLinksByKey.set(key, link);
+    }
+  }
+  const dedupedTestLinks = [...dedupedTestLinksByKey.values()];
   const insertTestFile = db.prepare(
     `INSERT INTO test_files
      (repo_id, path, language, size_bytes, content_hash, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?)`
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(repo_id, path) DO UPDATE SET
+       language = excluded.language,
+       size_bytes = excluded.size_bytes,
+       content_hash = excluded.content_hash,
+       updated_at = excluded.updated_at`
   );
   options.onProgress?.({
     stage: "writing_test_awareness",
     repo,
     current: 0,
-    total: testFiles.length,
+    total: dedupedTestFiles.length,
     kind: "test_files"
   });
-  for (const [index, file] of testFiles.entries()) {
+  for (const [index, file] of dedupedTestFiles.entries()) {
     insertTestFile.run(
       repoId,
       file.path,
@@ -2504,36 +2734,38 @@ function insertTestAwareness(db, repoId, repo, testFiles, testLinks, options = {
       file.updatedAt
     );
     const current = index + 1;
-    if (shouldEmitCodeWriteProgress(current, testFiles.length)) {
+    if (shouldEmitCodeWriteProgress(current, dedupedTestFiles.length)) {
       options.onProgress?.({
         stage: "writing_test_awareness",
         repo,
         current,
-        total: testFiles.length,
+        total: dedupedTestFiles.length,
         kind: "test_files"
       });
     }
   }
   const insertTestLink = db.prepare(
     `INSERT INTO test_links (repo_id, source_path, test_path, reason, strength)
-     VALUES (?, ?, ?, ?, ?)`
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(repo_id, source_path, test_path, reason) DO UPDATE SET
+       strength = excluded.strength`
   );
   options.onProgress?.({
     stage: "writing_test_awareness",
     repo,
     current: 0,
-    total: testLinks.length,
+    total: dedupedTestLinks.length,
     kind: "test_links"
   });
-  for (const [index, link] of testLinks.entries()) {
+  for (const [index, link] of dedupedTestLinks.entries()) {
     insertTestLink.run(repoId, link.sourcePath, link.testPath, link.reason, link.strength);
     const current = index + 1;
-    if (shouldEmitCodeWriteProgress(current, testLinks.length)) {
+    if (shouldEmitCodeWriteProgress(current, dedupedTestLinks.length)) {
       options.onProgress?.({
         stage: "writing_test_awareness",
         repo,
         current,
-        total: testLinks.length,
+        total: dedupedTestLinks.length,
         kind: "test_links"
       });
     }
@@ -3057,18 +3289,7 @@ function createPattern(input) {
   };
 }
 function buildArchitectureIndex(repo, files, chunks, options = {}) {
-  const allPaths = files.map((file) => file.path);
-  const codePaths = new Set(allPaths);
-  const relatedTestIndex = buildRelatedTestIndex(allPaths);
-  const symbolSetsByPath = /* @__PURE__ */ new Map();
-  for (const chunk of chunks) {
-    const existing = symbolSetsByPath.get(chunk.filePath) ?? /* @__PURE__ */ new Set();
-    for (const symbol of chunk.symbols) {
-      if (existing.size >= 40) break;
-      existing.add(symbol);
-    }
-    symbolSetsByPath.set(chunk.filePath, existing);
-  }
+  const codePaths = new Set(files.map((file) => file.path));
   const imports = [];
   options.onProgress?.({
     stage: "building_architecture_imports",
@@ -3091,6 +3312,20 @@ function buildArchitectureIndex(repo, files, chunks, options = {}) {
       });
     }
   }
+  return buildArchitectureFromIndexedData(repo, files, chunks, imports, options);
+}
+function buildArchitectureFromIndexedData(repo, files, chunks, imports, options = {}) {
+  const allPaths = files.map((file) => file.path);
+  const relatedTestIndex = buildRelatedTestIndex(allPaths);
+  const symbolSetsByPath = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    const existing = symbolSetsByPath.get(chunk.filePath) ?? /* @__PURE__ */ new Set();
+    for (const symbol of chunk.symbols) {
+      if (existing.size >= 40) break;
+      existing.add(symbol);
+    }
+    symbolSetsByPath.set(chunk.filePath, existing);
+  }
   const importsByPath = /* @__PURE__ */ new Map();
   for (const item of imports) {
     const existing = importsByPath.get(item.sourcePath) ?? [];
@@ -3106,7 +3341,7 @@ function buildArchitectureIndex(repo, files, chunks, options = {}) {
     components: 0
   });
   for (const [index, file] of files.entries()) {
-    const area = classifyArchitectureArea(file.path, file.language, file.content);
+    const area = classifyArchitectureArea(file.path, file.language);
     const fileImports = importsByPath.get(file.path) ?? [];
     const symbols = [...symbolSetsByPath.get(file.path) ?? []];
     components.push({
@@ -3320,15 +3555,134 @@ function discoverGitFiles(cwd) {
   });
   return output.split("\n").map((line) => normalizeGitPath(line.trim())).filter(Boolean);
 }
+function discoverGitUntrackedFiles(cwd) {
+  const output = execFileSync3("git", ["ls-files", "--others", "--exclude-standard"], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return output.split("\n").map((line) => normalizeGitPath(line.trim())).filter(Boolean);
+}
+function execGitLines(cwd, args) {
+  const output = execFileSync3("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return output.split("\n").map((line) => line.trimEnd()).filter(Boolean);
+}
+function readGitHeadCommit(cwd) {
+  try {
+    return execFileSync3("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function hasDirtyWorkingTree(cwd) {
+  try {
+    const status = execFileSync3("git", ["status", "--porcelain"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return status.trim().length > 0;
+  } catch {
+    return true;
+  }
+}
+function parseNameStatusLine(line) {
+  const parts = line.split("	").map((item) => normalizeGitPath(item));
+  if (parts.length < 2) return void 0;
+  const status = parts[0] ?? "";
+  if (!status) return void 0;
+  if (status.startsWith("R") || status.startsWith("C")) {
+    return { status, previousPath: parts[1], path: parts[2] };
+  }
+  return { status, path: parts[1] };
+}
+function planIncrementalCodeIndex(cwd, lastIndexedCommit, existingIndexedPaths) {
+  const currentCommit2 = readGitHeadCommit(cwd);
+  const trackedPaths = discoverGitFiles(cwd);
+  const trackedSet = new Set(trackedPaths);
+  const deletedPaths = /* @__PURE__ */ new Set();
+  const changedPaths = /* @__PURE__ */ new Set();
+  const dirtyWorkingTree = hasDirtyWorkingTree(cwd);
+  if (!lastIndexedCommit) {
+    return {
+      currentCommit: currentCommit2,
+      trackedPaths,
+      changedPaths: trackedPaths,
+      deletedPaths: [...existingIndexedPaths].filter((filePath) => !trackedSet.has(filePath)),
+      dirtyWorkingTree,
+      fallbackToFullHashCompare: true,
+      reason: "No previous commit snapshot; using full hash comparison."
+    };
+  }
+  if (dirtyWorkingTree) {
+    return {
+      currentCommit: currentCommit2,
+      trackedPaths,
+      changedPaths: trackedPaths,
+      deletedPaths: [...existingIndexedPaths].filter((filePath) => !trackedSet.has(filePath)),
+      dirtyWorkingTree,
+      fallbackToFullHashCompare: true,
+      reason: "Working tree is dirty; using full hash comparison for deterministic results."
+    };
+  }
+  try {
+    const lines = execGitLines(cwd, ["diff", "--name-status", `${lastIndexedCommit}..HEAD`]);
+    for (const line of lines) {
+      const parsed = parseNameStatusLine(line);
+      if (!parsed?.path) continue;
+      const statusCode = parsed.status[0];
+      const normalizedPath = normalizeGitPath(parsed.path);
+      if (statusCode === "D") {
+        deletedPaths.add(normalizedPath);
+        continue;
+      }
+      if (trackedSet.has(normalizedPath)) changedPaths.add(normalizedPath);
+    }
+    for (const untrackedPath of discoverGitUntrackedFiles(cwd)) {
+      if (trackedSet.has(untrackedPath)) changedPaths.add(untrackedPath);
+    }
+    for (const existingPath of existingIndexedPaths) {
+      if (!trackedSet.has(existingPath)) deletedPaths.add(existingPath);
+    }
+    return {
+      currentCommit: currentCommit2,
+      trackedPaths,
+      changedPaths: [...changedPaths],
+      deletedPaths: [...deletedPaths],
+      dirtyWorkingTree: false,
+      fallbackToFullHashCompare: false,
+      reason: "Using git diff and untracked files against last indexed commit."
+    };
+  } catch {
+    return {
+      currentCommit: currentCommit2,
+      trackedPaths,
+      changedPaths: trackedPaths,
+      deletedPaths: [...existingIndexedPaths].filter((filePath) => !trackedSet.has(filePath)),
+      dirtyWorkingTree: true,
+      fallbackToFullHashCompare: true,
+      reason: "Unable to compute git diff; falling back to full hash comparison."
+    };
+  }
+}
 var DISCOVERY_SCAN_INTERVAL = 200;
-function discoverCodeFiles(cwd, repo, options = {}) {
+function discoverFromPaths(cwd, repo, inputPaths, options = {}) {
   const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_CODE_FILE_BYTES;
+  const includeContent = options.includeContent ?? false;
   const rootPath = path7.resolve(cwd);
   const files = [];
   let skippedFiles = 0;
-  const gitFiles = discoverGitFiles(cwd);
-  const total = gitFiles.length;
-  for (const [scanIndex, filePath] of gitFiles.entries()) {
+  const candidatePaths = [...new Set(inputPaths.map((value) => normalizeGitPath(value)).filter(Boolean))];
+  const total = candidatePaths.length;
+  for (const [scanIndex, filePath] of candidatePaths.entries()) {
     const scanned = scanIndex + 1;
     if (scanned % DISCOVERY_SCAN_INTERVAL === 0 || scanned === total) {
       options.onScan?.(scanned, total);
@@ -3359,7 +3713,6 @@ function discoverCodeFiles(cwd, repo, options = {}) {
       skippedFiles += 1;
       continue;
     }
-    const content = buffer.toString("utf8");
     files.push({
       repo,
       path: filePath,
@@ -3368,11 +3721,21 @@ function discoverCodeFiles(cwd, repo, options = {}) {
       contentHash: crypto3.createHash("sha256").update(buffer).digest("hex"),
       updatedAt: stat.mtime.toISOString(),
       absolutePath,
-      content
+      ...includeContent ? { content: buffer.toString("utf8") } : {}
     });
   }
   return { files, skippedFiles };
 }
+function discoverCodeFiles(cwd, repo, options = {}) {
+  return discoverFromPaths(cwd, repo, discoverGitFiles(cwd), options);
+}
+function discoverCodeFilesByPaths(cwd, repo, filePaths, options = {}) {
+  return discoverFromPaths(cwd, repo, filePaths, options);
+}
+function readDiscoveredCodeFileContent(file) {
+  if (typeof file.content === "string") return file.content;
+  return fs4.readFileSync(file.absolutePath, "utf8");
+}
 
 // src/retrieval/test-commands.ts
 import crypto4 from "crypto";
@@ -3606,40 +3969,154 @@ function refreshTestCommands(db, cwd, repo, files = [], options = {}) {
 
 // src/indexer/code-indexer.ts
 function indexCodebase(db, options) {
+  const state = getCodeIndexStateForRepo(db, options.repo);
+  const existingHashes = getRepoCodeFileHashes(db, options.repo);
+  const plan = planIncrementalCodeIndex(
+    options.cwd,
+    state?.lastIndexedCommit,
+    new Set(existingHashes.keys())
+  );
   options.onProgress?.({ stage: "discovering_code_files", repo: options.repo });
-  const discovery = discoverCodeFiles(options.cwd, options.repo, {
+  const discovery = plan.fallbackToFullHashCompare ? discoverCodeFiles(options.cwd, options.repo, {
+    maxFileBytes: options.maxFileBytes,
+    onScan: (scanned, total) => options.onProgress?.({
+      stage: "discovering_code_files",
+      repo: options.repo,
+      scanned,
+      total
+    })
+  }) : discoverCodeFilesByPaths(options.cwd, options.repo, plan.changedPaths, {
     maxFileBytes: options.maxFileBytes,
-    onScan: (scanned, total) => options.onProgress?.({ stage: "discovering_code_files", repo: options.repo, scanned, total })
+    onScan: (scanned, total) => options.onProgress?.({
+      stage: "discovering_code_files",
+      repo: options.repo,
+      scanned,
+      total
+    })
   });
+  const changedFiles = discovery.files.filter(
+    (file) => existingHashes.get(file.path) !== file.contentHash
+  );
+  const discoveredPaths = new Set(discovery.files.map((file) => file.path));
+  const deletedPaths = plan.fallbackToFullHashCompare ? [...existingHashes.keys()].filter((filePath) => !discoveredPaths.has(filePath)) : plan.deletedPaths;
   options.onProgress?.({
     stage: "discovered_code_files",
     repo: options.repo,
-    files: discovery.files.length,
+    files: changedFiles.length,
     skippedFiles: discovery.skippedFiles
   });
-  const chunks = [];
-  for (const [index, file] of discovery.files.entries()) {
+  if (changedFiles.length === 0 && deletedPaths.length === 0) {
+    const counts = touchCodeIndexState(
+      db,
+      options.repo,
+      discovery.skippedFiles,
+      plan.currentCommit
+    );
+    const repoId = ensureRepository(db, options.repo);
+    const scopedCount = (table) => db.prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE repo_id = ?`).get(repoId).count;
+    const summary2 = {
+      indexedFiles: counts.files,
+      codeChunksCreated: counts.chunks,
+      testFilesIndexed: scopedCount("test_files"),
+      testLinksCreated: scopedCount("test_links"),
+      architectureComponentsIndexed: scopedCount("architecture_components"),
+      architecturePatternsIndexed: scopedCount("architecture_patterns"),
+      architectureImportsIndexed: scopedCount("code_imports"),
+      skippedFiles: discovery.skippedFiles,
+      databasePath: defaultDatabasePath(options.cwd)
+    };
+    options.onProgress?.({
+      stage: "completed_code_index",
+      repo: options.repo,
+      files: summary2.indexedFiles,
+      chunks: summary2.codeChunksCreated,
+      skippedFiles: summary2.skippedFiles,
+      testFiles: summary2.testFilesIndexed,
+      testLinks: summary2.testLinksCreated,
+      architectureComponents: summary2.architectureComponentsIndexed,
+      architecturePatterns: summary2.architecturePatternsIndexed,
+      architectureImports: summary2.architectureImportsIndexed
+    });
+    return summary2;
+  }
+  const changedChunks = [];
+  const changedImports = [];
+  const projectedIndexedPaths = new Set(
+    [...existingHashes.keys()].filter((filePath) => !deletedPaths.includes(filePath))
+  );
+  for (const file of changedFiles) projectedIndexedPaths.add(file.path);
+  for (const [index, file] of changedFiles.entries()) {
     options.onProgress?.({
       stage: "indexing_code_file",
       repo: options.repo,
       current: index + 1,
-      total: discovery.files.length,
+      total: changedFiles.length,
       filePath: file.path
     });
-    const fileChunks = chunkCodeFile(file);
-    chunks.push(...fileChunks);
+    const content = readDiscoveredCodeFileContent(file);
+    const fileWithContent = { ...file, content };
+    const fileChunks = chunkCodeFile(fileWithContent);
+    changedChunks.push(...fileChunks);
+    changedImports.push(
+      ...extractCodeImports(file.path, content, projectedIndexedPaths, options.repo)
+    );
     options.onProgress?.({
       stage: "indexed_code_file",
       repo: options.repo,
       current: index + 1,
-      total: discovery.files.length,
+      total: changedFiles.length,
       filePath: file.path,
       chunks: fileChunks.length
     });
   }
-  const architecture = buildArchitectureIndex(options.repo, discovery.files, chunks, {
+  const affectedPaths = /* @__PURE__ */ new Set([
+    ...deletedPaths,
+    ...changedFiles.map((file) => file.path)
+  ]);
+  const allFilesByPath = new Map(getRepoCodeFiles(db, options.repo).map((file) => [file.path, file]));
+  for (const filePath of deletedPaths) allFilesByPath.delete(filePath);
+  for (const file of changedFiles) {
+    allFilesByPath.set(file.path, {
+      repo: file.repo,
+      path: file.path,
+      language: file.language,
+      sizeBytes: file.sizeBytes,
+      contentHash: file.contentHash,
+      updatedAt: file.updatedAt
+    });
+  }
+  const allFiles = [...allFilesByPath.values()];
+  const allSymbolChunks = getRepoCodeChunkSymbols(db, options.repo).filter(
+    (chunk) => !affectedPaths.has(chunk.filePath)
+  );
+  allSymbolChunks.push(...changedChunks);
+  const allImports = getRepoCodeImports(db, options.repo).filter(
+    (item) => !affectedPaths.has(item.sourcePath)
+  );
+  allImports.push(...changedImports);
+  const testChunks = getRepoTestChunks(db, options.repo).filter(
+    (chunk) => !affectedPaths.has(chunk.filePath)
+  );
+  for (const chunk of changedChunks) {
+    if (isTestFilePath(chunk.filePath)) testChunks.push(chunk);
+  }
+  const testAwareness = inferTestAwareness(options.repo, allFiles, testChunks, {
     onProgress: options.onProgress
   });
+  options.onProgress?.({
+    stage: "building_architecture_imports",
+    repo: options.repo,
+    current: allFiles.length,
+    total: allFiles.length,
+    imports: allImports.length
+  });
+  const architecture = buildArchitectureFromIndexedData(
+    options.repo,
+    allFiles,
+    allSymbolChunks,
+    allImports,
+    { onProgress: options.onProgress }
+  );
   options.onProgress?.({
     stage: "indexed_architecture",
     repo: options.repo,
@@ -3650,14 +4127,22 @@ function indexCodebase(db, options) {
   const summary = replaceCodeIndex(
     db,
     options.repo,
-    discovery.files.map(({ content: _content, absolutePath: _absolutePath, ...file }) => file),
-    chunks,
+    changedFiles.map(({ content: _content, absolutePath: _absolutePath, ...file }) => file),
+    changedChunks,
     discovery.skippedFiles,
     options.cwd,
     architecture,
-    { onProgress: options.onProgress }
+    {
+      onProgress: options.onProgress,
+      deletedPaths,
+      changedImports,
+      currentCommit: plan.currentCommit,
+      testAwareness
+    }
   );
-  refreshTestCommands(db, options.cwd, options.repo, [], { onProgress: options.onProgress });
+  refreshTestCommands(db, options.cwd, options.repo, [], {
+    onProgress: options.onProgress
+  });
   options.onProgress?.({
     stage: "completed_code_index",
     repo: options.repo,
@@ -4096,7 +4581,7 @@ function clampMaxResults(value, defaultValue) {
 
 // src/retrieval/ranker.ts
 import path11 from "path";
-function parseJsonArray3(value) {
+function parseJsonArray4(value) {
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
@@ -4114,9 +4599,9 @@ function rowToWisdomUnit(row) {
     category: row.category,
     text: row.text,
     sanitizedText: row.sanitized_text,
-    filePaths: parseJsonArray3(row.file_paths_json),
-    symbols: parseJsonArray3(row.symbols_json),
-    authors: parseJsonArray3(row.authors_json),
+    filePaths: parseJsonArray4(row.file_paths_json),
+    symbols: parseJsonArray4(row.symbols_json),
+    authors: parseJsonArray4(row.authors_json),
     createdAt: row.created_at,
     mergedAt: row.merged_at ?? void 0,
     confidence: row.confidence,
@@ -4179,11 +4664,11 @@ function symbolMatch2(unit, querySymbols) {
 }
 function textMatch2(unit, inputText) {
   const queryTokens = tokenizeSearchText(inputText, 32);
-  if (queryTokens.length === 0) return unit.bm25 === void 0 ? 0 : 0.45;
+  if (queryTokens.length === 0) return unit.bm25 === void 0 ? 0 : 0.35;
   const haystack = `${unit.sanitizedText} ${unit.filePaths.join(" ")} ${unit.symbols.join(" ")}`.toLowerCase();
   const overlap = queryTokens.filter((token) => haystack.includes(token.toLowerCase())).length / queryTokens.length;
-  const bm25Signal = unit.bm25 === void 0 ? 0 : Math.max(0.25, Math.min(1, 1 / (1 + Math.abs(unit.bm25))));
-  return Math.max(overlap, bm25Signal);
+  const bm25Signal = unit.bm25 === void 0 ? 0 : Math.max(0, Math.min(1, 1 / (1 + Math.abs(unit.bm25))));
+  return unit.bm25 === void 0 ? overlap : Number((0.65 * overlap + 0.35 * bm25Signal).toFixed(4));
 }
 function reviewerOrAuthorSignal(unit) {
   if (unit.sourceType === "review_comment" || unit.sourceType === "review_summary") return 0.9;
@@ -4375,7 +4860,7 @@ function rankWisdomUnits(db, input) {
 
 // src/retrieval/code-ranker.ts
 import path12 from "path";
-function parseJsonArray4(value) {
+function parseJsonArray5(value) {
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
@@ -4392,7 +4877,7 @@ function rowToCodeChunk(row) {
     startLine: row.start_line,
     endLine: row.end_line,
     sanitizedText: row.sanitized_text,
-    symbols: parseJsonArray4(row.symbols_json),
+    symbols: parseJsonArray5(row.symbols_json),
     contentHash: row.content_hash,
     updatedAt: row.updated_at,
     bm25: row.bm25 ?? void 0
@@ -4441,8 +4926,8 @@ function textMatch3(chunk, input) {
   );
   const haystack = `${chunk.sanitizedText} ${chunk.filePath} ${chunk.symbols.join(" ")}`.toLowerCase();
   const overlap = tokens.length ? tokens.filter((token) => haystack.includes(token.toLowerCase())).length / tokens.length : 0;
-  const bm25Signal = chunk.bm25 === void 0 ? 0 : Math.max(0.25, Math.min(1, 1 / (1 + Math.abs(chunk.bm25))));
-  return Math.max(overlap, bm25Signal);
+  const bm25Signal = chunk.bm25 === void 0 ? 0 : Math.max(0, Math.min(1, 1 / (1 + Math.abs(chunk.bm25))));
+  return chunk.bm25 === void 0 ? overlap : Number((0.65 * overlap + 0.35 * bm25Signal).toFixed(4));
 }
 function recencyScore2(chunk) {
   const timestamp = Date.parse(chunk.updatedAt);
@@ -4540,7 +5025,7 @@ function rankCodeChunks(db, input) {
 
 // src/retrieval/architecture-ranker.ts
 import path13 from "path";
-function parseJsonArray5(value) {
+function parseJsonArray6(value) {
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
@@ -4564,8 +5049,8 @@ function rowToPattern(row) {
     name: row.name,
     summary: row.summary_sanitized,
     sanitizedSummary: row.summary_sanitized,
-    sourceFiles: parseJsonArray5(row.source_files_json),
-    symbols: parseJsonArray5(row.symbols_json),
+    sourceFiles: parseJsonArray6(row.source_files_json),
+    symbols: parseJsonArray6(row.symbols_json),
     evidence: parseEvidence(row.evidence_json),
     confidence: row.confidence,
     createdAt: row.created_at,
@@ -4681,7 +5166,7 @@ function rankArchitecturePatterns(db, input) {
 
 // src/retrieval/test-ranker.ts
 import path14 from "path";
-function parseJsonArray6(value) {
+function parseJsonArray7(value) {
   if (!value) return [];
   try {
     const parsed = JSON.parse(value);
@@ -4694,7 +5179,7 @@ function baseStem(filePath) {
   return path14.posix.basename(filePath).replace(/\.(test|spec)\.[^.]+$/i, "").replace(/\.[^.]+$/i, "").toLowerCase();
 }
 function rowToRanked(row, input) {
-  const symbols = parseJsonArray6(row.symbols_json);
+  const symbols = parseJsonArray7(row.symbols_json);
   const text = row.sanitized_text ?? "";
   const matchedSymbols = (input.symbols ?? []).filter((symbol) => {
     const lower = symbol.toLowerCase();
@@ -4764,7 +5249,7 @@ function rankRelevantTests(db, input) {
 
 // src/retrieval/regression-ranker.ts
 import path15 from "path";
-function parseJsonArray7(value) {
+function parseJsonArray8(value) {
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
@@ -4779,12 +5264,12 @@ function rowToEvent(row) {
     prNumber: row.pr_number,
     prUrl: row.pr_url,
     summary: row.summary_sanitized,
-    filePaths: parseJsonArray7(row.file_paths_json),
-    symbols: parseJsonArray7(row.symbols_json),
-    testPaths: parseJsonArray7(row.test_paths_json),
-    authors: parseJsonArray7(row.authors_json),
-    labels: parseJsonArray7(row.labels_json),
-    signals: parseJsonArray7(row.signals_json),
+    filePaths: parseJsonArray8(row.file_paths_json),
+    symbols: parseJsonArray8(row.symbols_json),
+    testPaths: parseJsonArray8(row.test_paths_json),
+    authors: parseJsonArray8(row.authors_json),
+    labels: parseJsonArray8(row.labels_json),
+    signals: parseJsonArray8(row.signals_json),
     createdAt: row.created_at,
     mergedAt: row.merged_at ?? void 0,
     confidence: row.confidence
@@ -6184,7 +6669,7 @@ function syncPlaybooksToDatabase(db, cwd) {
 }
 
 // src/retrieval/onboarding.ts
-function parseJsonArray8(value) {
+function parseJsonArray9(value) {
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
@@ -6217,7 +6702,7 @@ function riskyModules(db) {
        ORDER BY confidence DESC, COALESCE(merged_at, created_at) DESC
        LIMIT 20`
   ).all();
-  return [...new Set(rows.flatMap((row) => parseJsonArray8(row.file_paths_json)))].slice(0, 10);
+  return [...new Set(rows.flatMap((row) => parseJsonArray9(row.file_paths_json)))].slice(0, 10);
 }
 function relatedTests(db, files) {
   if (files.length === 0) {
@@ -6296,6 +6781,7 @@ import crypto8 from "crypto";
 import fs7 from "fs";
 import path18 from "path";
 var ANCHOR_EVALS_FILE = "anchor.evals.json";
+var DEFAULT_EVAL_K = 8;
 function evalsPath(cwd) {
   return path18.join(cwd, ANCHOR_EVALS_FILE);
 }
@@ -6394,6 +6880,7 @@ function runRetrievalEvals(db, cwd) {
   initializeSchema(db);
   const filePath = evalsPath(cwd);
   const evalFile = readEvalFile(cwd);
+  const k = DEFAULT_EVAL_K;
   const results = evalFile.evals.map((item) => {
     const context = buildAnchorContextResult(db, cwd, {
       task: item.task,
@@ -6404,6 +6891,9 @@ function runRetrievalEvals(db, cwd) {
       ...Array.isArray(context.metadata.items) ? context.metadata.items : [],
       ...Array.isArray(context.metadata.teamRules) ? context.metadata.teamRules : []
     ];
+    const rankedPrs = uniqueStrings(
+      metadataItems.map((metadata) => metadata.prNumber).filter((prNumber) => typeof prNumber === "number").map(String)
+    ).map(Number);
     const foundPrs = uniqueStrings(
       metadataItems.map((metadata) => metadata.prNumber).filter((prNumber) => typeof prNumber === "number").map(String)
     ).map(Number);
@@ -6414,6 +6904,23 @@ function runRetrievalEvals(db, cwd) {
     const missingCategories = item.expectedCategories.filter(
       (category) => !foundCategories.includes(category)
     );
+    const expectedPrRanks = item.expectedPrs.map((prNumber) => {
+      const index = rankedPrs.indexOf(prNumber);
+      return {
+        prNumber,
+        rank: index >= 0 ? index + 1 : void 0
+      };
+    });
+    const topK = rankedPrs.slice(0, k);
+    const relevantInTopK = item.expectedPrs.filter((prNumber) => topK.includes(prNumber));
+    const precisionAtK2 = k > 0 ? Number((relevantInTopK.length / k).toFixed(4)) : 0;
+    const recallAtK2 = item.expectedPrs.length > 0 ? Number((relevantInTopK.length / item.expectedPrs.length).toFixed(4)) : 0;
+    const reciprocalRank = (() => {
+      if (item.expectedPrs.length === 0) return 0;
+      const firstRank = expectedPrRanks.map((entry) => entry.rank).filter((rank) => typeof rank === "number").sort((a, b) => a - b)[0];
+      if (!firstRank) return 0;
+      return Number((1 / firstRank).toFixed(4));
+    })();
     return {
       id: item.id,
       task: item.task,
@@ -6421,18 +6928,35 @@ function runRetrievalEvals(db, cwd) {
       expectedPrs: item.expectedPrs,
       foundPrs,
       missingPrs,
+      expectedPrRanks,
       expectedCategories: item.expectedCategories,
       foundCategories,
-      missingCategories
+      missingCategories,
+      precisionAtK: precisionAtK2,
+      recallAtK: recallAtK2,
+      reciprocalRank
     };
   });
   const passed = results.filter((result) => result.passed).length;
+  const precisionAtK = results.length > 0 ? Number(
+    (results.reduce((sum, result) => sum + result.precisionAtK, 0) / results.length).toFixed(4)
+  ) : 0;
+  const recallAtK = results.length > 0 ? Number(
+    (results.reduce((sum, result) => sum + result.recallAtK, 0) / results.length).toFixed(4)
+  ) : 0;
+  const mrr = results.length > 0 ? Number(
+    (results.reduce((sum, result) => sum + result.reciprocalRank, 0) / results.length).toFixed(4)
+  ) : 0;
   return {
     ok: passed === results.length,
     path: filePath,
     total: results.length,
     passed,
     failed: results.length - passed,
+    precisionAtK,
+    recallAtK,
+    mrr,
+    k,
     results
   };
 }
@@ -8787,7 +9311,7 @@ function packageRootForSpecifier(specifier) {
   if (normalized.startsWith("@") && parts.length >= 2) return `${parts[0]}/${parts[1]}`;
   return parts[0] ?? "";
 }
-function parseJsonArray9(value) {
+function parseJsonArray10(value) {
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
@@ -8921,7 +9445,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
               `imports ${sanitizeHistoricalText(rootSpecifier || item.specifier)}`
             )
           ],
-          confidence: parseJsonArray9(item.imported_symbols_json).length > 0 ? 0.88 : 0.76
+          confidence: parseJsonArray10(item.imported_symbols_json).length > 0 ? 0.88 : 0.76
         });
       }
       if (shouldEmitProgress3(index + 1, imports.length)) {
@@ -9257,7 +9781,11 @@ async function indexOrgRepos(db, config, options = {}) {
     command,
     totalRepos: repos.length
   });
-  for (const [repoIndex, repo] of repos.entries()) {
+  const maxConcurrency = Math.max(1, Math.min(options.concurrency ?? 3, 4));
+  let nextRepoIndex = 0;
+  const processRepo = async (repoIndex) => {
+    const repo = repos[repoIndex];
+    if (!repo) return;
     const repoPosition = repoIndex + 1;
     const localPath = orgRepoLocalPath(config.org, repo, options.baseDir);
     const repoStartedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -9508,7 +10036,18 @@ async function indexOrgRepos(db, config, options = {}) {
         error: message
       });
     }
-  }
+  };
+  const worker = async () => {
+    while (true) {
+      const repoIndex = nextRepoIndex;
+      nextRepoIndex += 1;
+      if (repoIndex >= repos.length) return;
+      await processRepo(repoIndex);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(maxConcurrency, repos.length) }, () => worker())
+  );
   let graph;
   if (options.noGraph) {
     const counts = getOrgGraphCounts(db, config.org);
@@ -9553,6 +10092,7 @@ async function indexOrgRepos(db, config, options = {}) {
     codeFilesIndexed: results.reduce((sum, result) => sum + (result.code?.indexedFiles ?? 0), 0),
     failures: results.map((result) => result.error).concat(graph.error ? [graph.error] : []).filter((error) => Boolean(error))
   });
+  runDatabaseMaintenance(db);
   emit({
     stage: "org_sync_completed",
     org: config.org,
@@ -10440,6 +10980,7 @@ export {
   anchorMcpEntry,
   architectureFilesFromDiff,
   buildAnchorContextResult,
+  buildArchitectureFromIndexedData,
   buildArchitectureIndex,
   buildArchitectureMap,
   buildFtsQuery,
@@ -10479,6 +11020,7 @@ export {
   detectTestCommands,
   detectTestCommandsForFile,
   discoverCodeFiles,
+  discoverCodeFilesByPaths,
   emptyCodeIndexSummary,
   ensureAnchorGitExclude,
   ensureCursorConfig,
@@ -10507,6 +11049,7 @@ export {
   getAnchorIndexHealth,
   getArchitectureContext,
   getArchitectureMapContext,
+  getCodeIndexStateForRepo,
   getGitHubRateLimitDelayMs,
   getGraphQLFetchCheckpoint,
   getIndexStatus,
@@ -10517,12 +11060,19 @@ export {
   getOrgRepoState,
   getOrgStatus,
   getPlaybook,
+  getRepoCodeChunkSymbols,
+  getRepoCodeCounts,
+  getRepoCodeFileHashes,
+  getRepoCodeFiles,
+  getRepoCodeImports,
+  getRepoTestChunks,
   getSemanticStatus,
   getSuggestedPromptTexts,
   getSuggestedPrompts,
   getWisdomCategoryCounts,
   githubAuthFixMessage,
   graphQLFetchCheckpointScope,
+  hasDirtyWorkingTree,
   hasHighSignalLanguage,
   indexCodebase,
   indexOrgRepos,
@@ -10558,6 +11108,7 @@ export {
   orgRoot,
   paginateWithGitHubRateLimit,
   parseGitHubRemote,
+  planIncrementalCodeIndex,
   planTask,
   plannedOrgCloneCommands,
   rankArchitecturePatterns,
@@ -10566,6 +11117,8 @@ export {
   rankRelevantTests,
   rankTeamRules,
   rankWisdomUnits,
+  readDiscoveredCodeFileContent,
+  readGitHeadCommit,
   readOrgHeartbeat,
   rebuildOrgGraph,
   recordFeedback,
@@ -10586,6 +11139,7 @@ export {
   resolvePullRequestFetchLimit,
   reviewDiff,
   runAnchorCi,
+  runDatabaseMaintenance,
   runDoctor,
   runRetrievalEvals,
   sanitizeHistoricalText,
@@ -10600,6 +11154,7 @@ export {
   syncOrgConfigToDatabase,
   syncPlaybooksToDatabase,
   tokenizeSearchText,
+  touchCodeIndexState,
   truncateText,
   uniqueStrings,
   updateGitHubGraphQLRateLimitState,