@pratik7368patil/anchor-core 0.1.29 → 0.1.31

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 (
@@ -1710,9 +1714,28 @@ function calculateCoverage(input) {
 
 // src/db/database.ts
 var CODE_WRITE_PROGRESS_INTERVAL = 150;
+var FTS_DELETE_BATCH_SIZE = 500;
 function shouldEmitCodeWriteProgress(current, total) {
   return current === 0 || current === 1 || current === total || current % CODE_WRITE_PROGRESS_INTERVAL === 0;
 }
+function shouldEmitFtsDeleteProgress(current, total) {
+  return current === 0 || current === 1 || current === total || current % FTS_DELETE_BATCH_SIZE === 0;
+}
+function deleteFtsRowsByRowId(db, ftsTable, rowIds, onProgress) {
+  if (rowIds.length === 0) {
+    onProgress?.(0, 0);
+    return;
+  }
+  const deleteRow = db.prepare(`DELETE FROM ${ftsTable} WHERE rowid = ?`);
+  onProgress?.(0, rowIds.length);
+  for (const [index, rowId] of rowIds.entries()) {
+    deleteRow.run(rowId);
+    const current = index + 1;
+    if (shouldEmitFtsDeleteProgress(current, rowIds.length)) {
+      onProgress?.(current, rowIds.length);
+    }
+  }
+}
 function defaultDatabasePath(cwd) {
   return path4.join(cwd, ".anchor", "index.sqlite");
 }
@@ -1738,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");
@@ -1751,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();
@@ -1800,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(
@@ -1905,9 +2080,12 @@ function clearGraphQLFetchCheckpoint(db, repo, scope) {
   ).run((/* @__PURE__ */ new Date()).toISOString(), repo);
 }
 function deleteExistingPrData(db, prId) {
-  db.prepare(
-    "DELETE FROM wisdom_units_fts WHERE unitId IN (SELECT id FROM wisdom_units WHERE pr_id = ?)"
-  ).run(prId);
+  const wisdomRowIds = db.prepare("SELECT rowid FROM wisdom_units WHERE pr_id = ?").all(prId);
+  deleteFtsRowsByRowId(
+    db,
+    "wisdom_units_fts",
+    wisdomRowIds.map((row) => row.rowid)
+  );
   db.prepare("DELETE FROM regression_events WHERE pr_id = ?").run(prId);
   db.prepare("DELETE FROM wisdom_units WHERE pr_id = ?").run(prId);
   db.prepare("DELETE FROM pr_comments WHERE pr_id = ?").run(prId);
@@ -2019,11 +2197,11 @@ function upsertPullRequest(db, pr, wisdomUnits, regressionEvents = []) {
     );
     const insertFts = db.prepare(
       `INSERT INTO wisdom_units_fts
-       (unitId, sanitizedText, filePaths, symbols, prTitle, prBody, category)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`
+       (rowid, unitId, sanitizedText, filePaths, symbols, prTitle, prBody, category)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
     );
     for (const unit of wisdomUnits) {
-      insertWisdom.run(
+      const wisdomInsert = insertWisdom.run(
         unit.id,
         repoId,
         prRow.id,
@@ -2042,6 +2220,7 @@ function upsertPullRequest(db, pr, wisdomUnits, regressionEvents = []) {
         unit.confidence
       );
       insertFts.run(
+        Number(wisdomInsert.lastInsertRowid),
         unit.id,
         unit.sanitizedText,
         unit.filePaths.join(" "),
@@ -2092,28 +2271,88 @@ 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 existingChunkCount = db.prepare("SELECT COUNT(*) AS count FROM code_chunks WHERE repo_id = ?").get(repoId).count;
-    const existingPatternCount = db.prepare("SELECT COUNT(*) AS count FROM architecture_patterns WHERE repo_id = ?").get(repoId).count;
+    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",
       repo,
-      chunks: existingChunkCount,
-      patterns: existingPatternCount
+      chunks: existingChunkRowIds.length,
+      patterns: existingPatternRowIds.length
     });
-    db.prepare(
-      "DELETE FROM code_chunks_fts WHERE chunkId IN (SELECT id FROM code_chunks WHERE repo_id = ?)"
-    ).run(repoId);
-    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);
-    deleteExistingArchitectureData(db, repoId);
+    deleteFtsRowsByRowId(
+      db,
+      "code_chunks_fts",
+      existingChunkRowIds.map((row) => row.rowid),
+      (current, total) => options.onProgress?.({
+        stage: "deleting_code_fts",
+        repo,
+        current,
+        total,
+        chunks: existingChunkRowIds.length
+      })
+    );
+    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)
@@ -2155,8 +2394,8 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
     );
     const insertFts = db.prepare(
       `INSERT INTO code_chunks_fts
-       (chunkId, sanitizedText, filePath, symbols, language)
-       VALUES (?, ?, ?, ?, ?)`
+       (rowid, chunkId, sanitizedText, filePath, symbols, language)
+       VALUES (?, ?, ?, ?, ?, ?)`
     );
     options.onProgress?.({
       stage: "writing_code_chunks",
@@ -2169,7 +2408,7 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
     for (const [index, chunk] of codeChunks.entries()) {
       const fileId = fileIds.get(chunk.filePath);
       if (!fileId) continue;
-      insertChunk.run(
+      const chunkInsert = insertChunk.run(
         chunk.id,
         repoId,
         fileId,
@@ -2184,6 +2423,7 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
         chunk.updatedAt
       );
       insertFts.run(
+        Number(chunkInsert.lastInsertRowid),
         chunk.id,
         chunk.sanitizedText,
         chunk.filePath,
@@ -2204,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 (?, ?, ?, ?, ?)
@@ -2233,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,
@@ -2245,46 +2490,56 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
     databasePath: defaultDatabasePath(cwd)
   };
 }
-function deleteExistingArchitectureData(db, repoId) {
-  db.prepare(
-    "DELETE FROM architecture_patterns_fts WHERE patternId IN (SELECT id FROM architecture_patterns WHERE repo_id = ?)"
-  ).run(repoId);
+function deleteExistingArchitectureData(db, repoId, repo, patternRowIds, options = {}) {
+  deleteFtsRowsByRowId(
+    db,
+    "architecture_patterns_fts",
+    patternRowIds.map((row) => row.rowid),
+    (current, total) => options.onProgress?.({
+      stage: "deleting_architecture_fts",
+      repo,
+      current,
+      total,
+      patterns: patternRowIds.length
+    })
+  );
   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(
@@ -2331,8 +2586,8 @@ function insertArchitectureData(db, repoId, repo, architecture, options = {}) {
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   );
   const insertFts = db.prepare(
-    `INSERT INTO architecture_patterns_fts (patternId, summary, area, sourceFiles, symbols)
-     VALUES (?, ?, ?, ?, ?)`
+    `INSERT INTO architecture_patterns_fts (rowid, patternId, summary, area, sourceFiles, symbols)
+     VALUES (?, ?, ?, ?, ?, ?)`
   );
   options.onProgress?.({
     stage: "writing_architecture_data",
@@ -2342,7 +2597,7 @@ function insertArchitectureData(db, repoId, repo, architecture, options = {}) {
     kind: "patterns"
   });
   for (const [index, pattern] of architecture.patterns.entries()) {
-    insertPattern.run(
+    const patternInsert = insertPattern.run(
       pattern.id,
       repoId,
       pattern.repo,
@@ -2356,6 +2611,7 @@ function insertArchitectureData(db, repoId, repo, architecture, options = {}) {
       pattern.createdAt
     );
     insertFts.run(
+      Number(patternInsert.lastInsertRowid),
       pattern.id,
       pattern.sanitizedSummary,
       pattern.area,
@@ -3014,18 +3270,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",
@@ -3048,6 +3293,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) ?? [];
@@ -3063,7 +3322,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({
@@ -3277,15 +3536,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);
@@ -3316,7 +3694,6 @@ function discoverCodeFiles(cwd, repo, options = {}) {
       skippedFiles += 1;
       continue;
     }
-    const content = buffer.toString("utf8");
     files.push({
       repo,
       path: filePath,
@@ -3325,11 +3702,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";
@@ -3563,40 +3950,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,
@@ -3607,14 +4108,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,
@@ -4053,7 +4562,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") : [];
@@ -4071,9 +4580,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,
@@ -4136,11 +4645,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;
@@ -4332,7 +4841,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") : [];
@@ -4349,7 +4858,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
@@ -4398,8 +4907,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);
@@ -4497,7 +5006,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") : [];
@@ -4521,8 +5030,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,
@@ -4638,7 +5147,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);
@@ -4651,7 +5160,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();
@@ -4721,7 +5230,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") : [];
@@ -4736,12 +5245,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
@@ -6141,7 +6650,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") : [];
@@ -6174,7 +6683,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) {
@@ -6253,6 +6762,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);
 }
@@ -6351,6 +6861,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,
@@ -6361,6 +6872,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);
@@ -6371,6 +6885,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,
@@ -6378,18 +6909,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
   };
 }
@@ -8744,7 +9292,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") : [];
@@ -8878,7 +9426,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)) {
@@ -9214,7 +9762,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();
@@ -9465,7 +10017,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);
@@ -9510,6 +10073,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,
@@ -10397,6 +10961,7 @@ export {
   anchorMcpEntry,
   architectureFilesFromDiff,
   buildAnchorContextResult,
+  buildArchitectureFromIndexedData,
   buildArchitectureIndex,
   buildArchitectureMap,
   buildFtsQuery,
@@ -10436,6 +11001,7 @@ export {
   detectTestCommands,
   detectTestCommandsForFile,
   discoverCodeFiles,
+  discoverCodeFilesByPaths,
   emptyCodeIndexSummary,
   ensureAnchorGitExclude,
   ensureCursorConfig,
@@ -10464,6 +11030,7 @@ export {
   getAnchorIndexHealth,
   getArchitectureContext,
   getArchitectureMapContext,
+  getCodeIndexStateForRepo,
   getGitHubRateLimitDelayMs,
   getGraphQLFetchCheckpoint,
   getIndexStatus,
@@ -10474,12 +11041,19 @@ export {
   getOrgRepoState,
   getOrgStatus,
   getPlaybook,
+  getRepoCodeChunkSymbols,
+  getRepoCodeCounts,
+  getRepoCodeFileHashes,
+  getRepoCodeFiles,
+  getRepoCodeImports,
+  getRepoTestChunks,
   getSemanticStatus,
   getSuggestedPromptTexts,
   getSuggestedPrompts,
   getWisdomCategoryCounts,
   githubAuthFixMessage,
   graphQLFetchCheckpointScope,
+  hasDirtyWorkingTree,
   hasHighSignalLanguage,
   indexCodebase,
   indexOrgRepos,
@@ -10515,6 +11089,7 @@ export {
   orgRoot,
   paginateWithGitHubRateLimit,
   parseGitHubRemote,
+  planIncrementalCodeIndex,
   planTask,
   plannedOrgCloneCommands,
   rankArchitecturePatterns,
@@ -10523,6 +11098,8 @@ export {
   rankRelevantTests,
   rankTeamRules,
   rankWisdomUnits,
+  readDiscoveredCodeFileContent,
+  readGitHeadCommit,
   readOrgHeartbeat,
   rebuildOrgGraph,
   recordFeedback,
@@ -10543,6 +11120,7 @@ export {
   resolvePullRequestFetchLimit,
   reviewDiff,
   runAnchorCi,
+  runDatabaseMaintenance,
   runDoctor,
   runRetrievalEvals,
   sanitizeHistoricalText,
@@ -10557,6 +11135,7 @@ export {
   syncOrgConfigToDatabase,
   syncPlaybooksToDatabase,
   tokenizeSearchText,
+  touchCodeIndexState,
   truncateText,
   uniqueStrings,
   updateGitHubGraphQLRateLimitState,