@pratik7368patil/anchor-core 0.1.23 → 0.1.25

package/dist/index.js

@@ -1535,16 +1535,27 @@ function calculateCoverage(input) {
 }
 
 // src/db/database.ts
+var CODE_WRITE_PROGRESS_INTERVAL = 500;
+function shouldEmitCodeWriteProgress(current, total) {
+  return current === 0 || current === 1 || current === total || current % CODE_WRITE_PROGRESS_INTERVAL === 0;
+}
 function defaultDatabasePath(cwd) {
   return path4.join(cwd, ".anchor", "index.sqlite");
 }
 function openAnchorDatabase(cwd, databasePath = defaultDatabasePath(cwd)) {
   fs3.mkdirSync(path4.dirname(databasePath), { recursive: true });
   const db = new Database(databasePath);
+  db.pragma("busy_timeout = 5000");
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   return db;
 }
+function openAnchorDatabaseReadOnly(databasePath) {
+  const db = new Database(databasePath, { readonly: true, fileMustExist: true });
+  db.pragma("busy_timeout = 5000");
+  db.pragma("foreign_keys = ON");
+  return db;
+}
 function initializeSchema(db) {
   db.exec(SCHEMA_SQL);
   ensureColumn(db, "sync_state", "history_coverage", "TEXT");
@@ -1895,13 +1906,22 @@ function upsertPullRequest(db, pr, wisdomUnits, regressionEvents = []) {
     regressions: regressionEvents.length
   };
 }
-function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, architecture = { components: [], patterns: [], imports: [] }) {
+function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, architecture = { components: [], patterns: [], imports: [] }, options = {}) {
   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);
+  options.onProgress?.({ stage: "writing_code_index", repo, phase: "Writing code index" });
   const transaction = db.transaction(() => {
     const existingChunks = db.prepare("SELECT id FROM code_chunks WHERE repo_id = ?").all(repoId);
+    const existingPatternCount = db.prepare("SELECT COUNT(*) AS count FROM architecture_patterns WHERE repo_id = ?").get(repoId).count;
+    options.onProgress?.({
+      stage: "deleting_existing_code_index",
+      repo,
+      chunks: existingChunks.length,
+      patterns: existingPatternCount
+    });
     const deleteFts = db.prepare("DELETE FROM code_chunks_fts WHERE chunkId = ?");
     for (const row of existingChunks) deleteFts.run(row.id);
     db.prepare("DELETE FROM code_chunks WHERE repo_id = ?").run(repoId);
@@ -1914,7 +1934,13 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
        (repo_id, path, language, size_bytes, content_hash, updated_at)
        VALUES (?, ?, ?, ?, ?, ?)`
     );
-    for (const file of codeFiles) {
+    options.onProgress?.({
+      stage: "writing_code_files",
+      repo,
+      current: 0,
+      total: codeFiles.length
+    });
+    for (const [index, file] of codeFiles.entries()) {
       insertFile.run(
         repoId,
         file.path,
@@ -1923,6 +1949,16 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
         file.contentHash,
         file.updatedAt
       );
+      const current = index + 1;
+      if (shouldEmitCodeWriteProgress(current, codeFiles.length)) {
+        options.onProgress?.({
+          stage: "writing_code_files",
+          repo,
+          current,
+          total: codeFiles.length,
+          filePath: file.path
+        });
+      }
     }
     const fileRows = db.prepare("SELECT id, path FROM code_files WHERE repo_id = ?").all(repoId);
     const fileIds = new Map(fileRows.map((row) => [row.path, row.id]));
@@ -1937,7 +1973,15 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
        (chunkId, sanitizedText, filePath, symbols, language)
        VALUES (?, ?, ?, ?, ?)`
     );
-    for (const chunk of codeChunks) {
+    options.onProgress?.({
+      stage: "writing_code_chunks",
+      repo,
+      current: 0,
+      total: codeChunks.length,
+      chunks: 0
+    });
+    let writtenChunks = 0;
+    for (const [index, chunk] of codeChunks.entries()) {
       const fileId = fileIds.get(chunk.filePath);
       if (!fileId) continue;
       insertChunk.run(
@@ -1961,10 +2005,23 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
         chunk.symbols.join(" "),
         chunk.language ?? ""
       );
+      writtenChunks += 1;
+      const current = index + 1;
+      if (shouldEmitCodeWriteProgress(current, codeChunks.length)) {
+        options.onProgress?.({
+          stage: "writing_code_chunks",
+          repo,
+          current,
+          total: codeChunks.length,
+          filePath: chunk.filePath,
+          chunks: writtenChunks
+        });
+      }
     }
-    insertTestAwareness(db, repoId, testAwareness.testFiles, testAwareness.testLinks);
-    insertArchitectureData(db, repoId, architecture);
-    insertArchitectureMapEdges(db, repoId, repo, architecture, testAwareness.testLinks);
+    insertTestAwareness(db, repoId, repo, testAwareness.testFiles, testAwareness.testLinks, options);
+    insertArchitectureData(db, repoId, repo, architecture, options);
+    insertArchitectureMapEdges(db, repoId, repo, architecture, testAwareness.testLinks, options);
+    options.onProgress?.({ stage: "writing_code_index", repo, phase: "Updating index state" });
     db.prepare(
       `INSERT INTO code_index_state (repo, last_indexed_at, indexed_files, code_chunks, skipped_files)
        VALUES (?, ?, ?, ?, ?)
@@ -2012,13 +2069,20 @@ function deleteExistingArchitectureData(db, 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, architecture) {
+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 (?, ?, ?, ?, ?, ?)`
   );
-  for (const item of architecture.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,
@@ -2027,6 +2091,16 @@ function insertArchitectureData(db, repoId, architecture) {
       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(
     `INSERT INTO architecture_components
@@ -2034,7 +2108,14 @@ function insertArchitectureData(db, repoId, architecture) {
       confidence, updated_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   );
-  for (const component of architecture.components) {
+  options.onProgress?.({
+    stage: "writing_architecture_data",
+    repo,
+    current: 0,
+    total: architecture.components.length,
+    kind: "components"
+  });
+  for (const [index, component] of architecture.components.entries()) {
     insertComponent.run(
       repoId,
       component.path,
@@ -2047,6 +2128,16 @@ function insertArchitectureData(db, repoId, architecture) {
       component.confidence,
       component.updatedAt
     );
+    const current = index + 1;
+    if (shouldEmitCodeWriteProgress(current, architecture.components.length)) {
+      options.onProgress?.({
+        stage: "writing_architecture_data",
+        repo,
+        current,
+        total: architecture.components.length,
+        kind: "components"
+      });
+    }
   }
   const insertPattern = db.prepare(
     `INSERT INTO architecture_patterns
@@ -2058,7 +2149,14 @@ function insertArchitectureData(db, repoId, architecture) {
     `INSERT INTO architecture_patterns_fts (patternId, summary, area, sourceFiles, symbols)
      VALUES (?, ?, ?, ?, ?)`
   );
-  for (const pattern of architecture.patterns) {
+  options.onProgress?.({
+    stage: "writing_architecture_data",
+    repo,
+    current: 0,
+    total: architecture.patterns.length,
+    kind: "patterns"
+  });
+  for (const [index, pattern] of architecture.patterns.entries()) {
     insertPattern.run(
       pattern.id,
       repoId,
@@ -2079,9 +2177,19 @@ function insertArchitectureData(db, repoId, architecture) {
       pattern.sourceFiles.join(" "),
       pattern.symbols.join(" ")
     );
+    const current = index + 1;
+    if (shouldEmitCodeWriteProgress(current, architecture.patterns.length)) {
+      options.onProgress?.({
+        stage: "writing_architecture_data",
+        repo,
+        current,
+        total: architecture.patterns.length,
+        kind: "patterns"
+      });
+    }
   }
 }
-function insertArchitectureMapEdges(db, repoId, repo, architecture, testLinks) {
+function insertArchitectureMapEdges(db, repoId, repo, architecture, testLinks, options = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const insert = db.prepare(
     `INSERT INTO architecture_map_edges
@@ -2096,11 +2204,40 @@ function insertArchitectureMapEdges(db, repoId, repo, architecture, testLinks) {
     seen.add(id);
     insert.run(id, repoId, repo, sourcePath, targetPath, relationship, weight, now);
   };
+  const total = architecture.imports.length + testLinks.length;
+  let current = 0;
+  options.onProgress?.({
+    stage: "writing_architecture_map_edges",
+    repo,
+    current,
+    total,
+    edges: 0
+  });
   for (const item of architecture.imports) {
     if (item.importedPath) addEdge(item.sourcePath, item.importedPath, "imports", 0.9);
+    current += 1;
+    if (shouldEmitCodeWriteProgress(current, total)) {
+      options.onProgress?.({
+        stage: "writing_architecture_map_edges",
+        repo,
+        current,
+        total,
+        edges: seen.size
+      });
+    }
   }
   for (const link of testLinks) {
     addEdge(link.sourcePath, link.testPath, "tested_by", link.strength);
+    current += 1;
+    if (shouldEmitCodeWriteProgress(current, total)) {
+      options.onProgress?.({
+        stage: "writing_architecture_map_edges",
+        repo,
+        current,
+        total,
+        edges: seen.size
+      });
+    }
   }
 }
 function insertPrCochangeTestLinks(db, repoId, filePaths) {
@@ -2116,13 +2253,20 @@ function insertPrCochangeTestLinks(db, repoId, filePaths) {
     for (const testPath of testPaths) insert.run(repoId, sourcePath, testPath);
   }
 }
-function insertTestAwareness(db, repoId, testFiles, testLinks) {
+function insertTestAwareness(db, repoId, repo, testFiles, testLinks, options = {}) {
   const insertTestFile = db.prepare(
     `INSERT INTO test_files
      (repo_id, path, language, size_bytes, content_hash, updated_at)
      VALUES (?, ?, ?, ?, ?, ?)`
   );
-  for (const file of testFiles) {
+  options.onProgress?.({
+    stage: "writing_test_awareness",
+    repo,
+    current: 0,
+    total: testFiles.length,
+    kind: "test_files"
+  });
+  for (const [index, file] of testFiles.entries()) {
     insertTestFile.run(
       repoId,
       file.path,
@@ -2131,13 +2275,40 @@ function insertTestAwareness(db, repoId, testFiles, testLinks) {
       file.contentHash,
       file.updatedAt
     );
+    const current = index + 1;
+    if (shouldEmitCodeWriteProgress(current, testFiles.length)) {
+      options.onProgress?.({
+        stage: "writing_test_awareness",
+        repo,
+        current,
+        total: testFiles.length,
+        kind: "test_files"
+      });
+    }
   }
   const insertTestLink = db.prepare(
     `INSERT INTO test_links (repo_id, source_path, test_path, reason, strength)
      VALUES (?, ?, ?, ?, ?)`
   );
-  for (const link of testLinks) {
+  options.onProgress?.({
+    stage: "writing_test_awareness",
+    repo,
+    current: 0,
+    total: testLinks.length,
+    kind: "test_links"
+  });
+  for (const [index, link] of testLinks.entries()) {
     insertTestLink.run(repoId, link.sourcePath, link.testPath, link.reason, link.strength);
+    const current = index + 1;
+    if (shouldEmitCodeWriteProgress(current, testLinks.length)) {
+      options.onProgress?.({
+        stage: "writing_test_awareness",
+        repo,
+        current,
+        total: testLinks.length,
+        kind: "test_links"
+      });
+    }
   }
 }
 function recordIndexRun(db, run) {
@@ -2464,6 +2635,10 @@ function chunkCodeFile(file, options = {}) {
 import crypto2 from "crypto";
 import path6 from "path";
 var KNOWN_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+var ARCHITECTURE_PROGRESS_INTERVAL = 250;
+function shouldEmitProgress(current, total) {
+  return current === 0 || current === 1 || current === total || current % ARCHITECTURE_PROGRESS_INTERVAL === 0;
+}
 function classifyArchitectureArea(filePath, language, content = "") {
   const normalized = filePath.replace(/\\/g, "/").toLowerCase();
   const basename = path6.basename(normalized);
@@ -2611,7 +2786,7 @@ function createPattern(input) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function buildArchitectureIndex(repo, files, chunks) {
+function buildArchitectureIndex(repo, files, chunks, options = {}) {
   const allPaths = files.map((file) => file.path);
   const codePaths = new Set(allPaths);
   const symbolsByPath = /* @__PURE__ */ new Map();
@@ -2619,20 +2794,47 @@ function buildArchitectureIndex(repo, files, chunks) {
     const existing = symbolsByPath.get(chunk.filePath) ?? [];
     symbolsByPath.set(chunk.filePath, uniqueStrings([...existing, ...chunk.symbols]).slice(0, 40));
   }
-  const imports = files.flatMap(
-    (file) => extractCodeImports(file.path, file.content, codePaths, repo)
-  );
+  const imports = [];
+  options.onProgress?.({
+    stage: "building_architecture_imports",
+    repo,
+    current: 0,
+    total: files.length,
+    imports: 0
+  });
+  for (const [index, file] of files.entries()) {
+    imports.push(...extractCodeImports(file.path, file.content, codePaths, repo));
+    const current = index + 1;
+    if (shouldEmitProgress(current, files.length)) {
+      options.onProgress?.({
+        stage: "building_architecture_imports",
+        repo,
+        current,
+        total: files.length,
+        filePath: file.path,
+        imports: imports.length
+      });
+    }
+  }
   const importsByPath = /* @__PURE__ */ new Map();
   for (const item of imports) {
     const existing = importsByPath.get(item.sourcePath) ?? [];
     existing.push(item);
     importsByPath.set(item.sourcePath, existing);
   }
-  const components = files.map((file) => {
+  const components = [];
+  options.onProgress?.({
+    stage: "building_architecture_components",
+    repo,
+    current: 0,
+    total: files.length,
+    components: 0
+  });
+  for (const [index, file] of files.entries()) {
     const area = classifyArchitectureArea(file.path, file.language, file.content);
     const fileImports = importsByPath.get(file.path) ?? [];
     const symbols = symbolsByPath.get(file.path) ?? [];
-    return {
+    components.push({
       repo,
       path: file.path,
       area,
@@ -2645,16 +2847,49 @@ function buildArchitectureIndex(repo, files, chunks) {
       relatedTests: relatedTestsFor(file.path, allPaths),
       confidence: area === "unknown" ? 0.45 : 0.82,
       updatedAt: file.updatedAt
-    };
-  });
+    });
+    const current = index + 1;
+    if (shouldEmitProgress(current, files.length)) {
+      options.onProgress?.({
+        stage: "building_architecture_components",
+        repo,
+        current,
+        total: files.length,
+        filePath: file.path,
+        components: components.length
+      });
+    }
+  }
   const componentByPath = new Map(components.map((component) => [component.path, component]));
-  const patterns = [];
   const componentsByArea = /* @__PURE__ */ new Map();
   for (const component of components) {
     const existing = componentsByArea.get(component.area) ?? [];
     existing.push(component);
     componentsByArea.set(component.area, existing);
   }
+  const importDirectionCounts = /* @__PURE__ */ new Map();
+  for (const item of imports) {
+    if (!item.importedPath) continue;
+    const source = componentByPath.get(item.sourcePath);
+    const target = componentByPath.get(item.importedPath);
+    if (!source || !target || source.area === target.area) continue;
+    const key = `${source.area}->${target.area}`;
+    const existing = importDirectionCounts.get(key) ?? { count: 0, files: [], symbols: [] };
+    existing.count += 1;
+    existing.files.push(source.path, target.path);
+    existing.symbols.push(...item.importedSymbols);
+    importDirectionCounts.set(key, existing);
+  }
+  const patterns = [];
+  const patternTotal = componentsByArea.size + importDirectionCounts.size;
+  let patternProgress = 0;
+  options.onProgress?.({
+    stage: "building_architecture_patterns",
+    repo,
+    current: 0,
+    total: patternTotal,
+    patterns: 0
+  });
   for (const [area, areaComponents] of componentsByArea.entries()) {
     const filesForArea = areaComponents.map((component) => component.path);
     const directories = topDirectories(filesForArea);
@@ -2670,19 +2905,17 @@ function buildArchitectureIndex(repo, files, chunks) {
         confidence: 0.55 + Math.min(0.3, filesForArea.length * 0.04)
       })
     );
-  }
-  const importDirectionCounts = /* @__PURE__ */ new Map();
-  for (const item of imports) {
-    if (!item.importedPath) continue;
-    const source = componentByPath.get(item.sourcePath);
-    const target = componentByPath.get(item.importedPath);
-    if (!source || !target || source.area === target.area) continue;
-    const key = `${source.area}->${target.area}`;
-    const existing = importDirectionCounts.get(key) ?? { count: 0, files: [], symbols: [] };
-    existing.count += 1;
-    existing.files.push(source.path, target.path);
-    existing.symbols.push(...item.importedSymbols);
-    importDirectionCounts.set(key, existing);
+    patternProgress += 1;
+    if (shouldEmitProgress(patternProgress, patternTotal)) {
+      options.onProgress?.({
+        stage: "building_architecture_patterns",
+        repo,
+        current: patternProgress,
+        total: patternTotal,
+        area,
+        patterns: patterns.length
+      });
+    }
   }
   for (const [key, value] of importDirectionCounts.entries()) {
     const [sourceArea, targetArea] = key.split("->");
@@ -2697,6 +2930,17 @@ function buildArchitectureIndex(repo, files, chunks) {
         confidence: 0.62 + Math.min(0.25, value.count * 0.05)
       })
     );
+    patternProgress += 1;
+    if (shouldEmitProgress(patternProgress, patternTotal)) {
+      options.onProgress?.({
+        stage: "building_architecture_patterns",
+        repo,
+        current: patternProgress,
+        total: patternTotal,
+        area: sourceArea,
+        patterns: patterns.length
+      });
+    }
   }
   const testedComponents = components.filter((component) => component.relatedTests.length > 0);
   if (testedComponents.length > 0) {
@@ -3026,8 +3270,24 @@ function detectTestCommands(db, cwd, files = []) {
     return true;
   });
 }
-function refreshTestCommands(db, cwd, repo, files = []) {
+function refreshTestCommands(db, cwd, repo, files = [], options = {}) {
+  options.onProgress?.({
+    stage: "refreshing_test_commands",
+    repo,
+    phase: "detecting",
+    current: 0,
+    total: files.length,
+    commands: 0
+  });
   const commands = detectTestCommands(db, cwd, files);
+  options.onProgress?.({
+    stage: "refreshing_test_commands",
+    repo,
+    phase: "writing",
+    current: 0,
+    total: commands.length,
+    commands: commands.length
+  });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const transaction = db.transaction(() => {
     db.prepare("DELETE FROM test_commands WHERE repo = ?").run(repo);
@@ -3035,7 +3295,7 @@ function refreshTestCommands(db, cwd, repo, files = []) {
       `INSERT INTO test_commands (id, repo, file_path, command, reason, confidence, created_at)
        VALUES (?, ?, ?, ?, ?, ?, ?)`
     );
-    for (const command of commands) {
+    for (const [index, command] of commands.entries()) {
       insert.run(
         commandId(repo, command),
         repo,
@@ -3045,6 +3305,17 @@ function refreshTestCommands(db, cwd, repo, files = []) {
         command.confidence,
         now
       );
+      const current = index + 1;
+      if (current === 1 || current === commands.length || current % 250 === 0) {
+        options.onProgress?.({
+          stage: "refreshing_test_commands",
+          repo,
+          phase: "writing",
+          current,
+          total: commands.length,
+          commands: commands.length
+        });
+      }
     }
   });
   transaction();
@@ -3083,7 +3354,9 @@ function indexCodebase(db, options) {
       chunks: fileChunks.length
     });
   }
-  const architecture = buildArchitectureIndex(options.repo, discovery.files, chunks);
+  const architecture = buildArchitectureIndex(options.repo, discovery.files, chunks, {
+    onProgress: options.onProgress
+  });
   options.onProgress?.({
     stage: "indexed_architecture",
     repo: options.repo,
@@ -3098,9 +3371,22 @@ function indexCodebase(db, options) {
     chunks,
     discovery.skippedFiles,
     options.cwd,
-    architecture
+    architecture,
+    { onProgress: options.onProgress }
   );
-  refreshTestCommands(db, options.cwd, options.repo);
+  refreshTestCommands(db, options.cwd, options.repo, [], { onProgress: options.onProgress });
+  options.onProgress?.({
+    stage: "completed_code_index",
+    repo: options.repo,
+    files: summary.indexedFiles,
+    chunks: summary.codeChunksCreated,
+    skippedFiles: summary.skippedFiles,
+    testFiles: summary.testFilesIndexed,
+    testLinks: summary.testLinksCreated,
+    architectureComponents: summary.architectureComponentsIndexed,
+    architecturePatterns: summary.architecturePatternsIndexed,
+    architectureImports: summary.architectureImportsIndexed
+  });
   return summary;
 }
 function emptyCodeIndexSummary(cwd) {
@@ -3425,7 +3711,8 @@ function indexPullRequests(db, pullRequests, options) {
       current: index + 1,
       total: pullRequests.length,
       prNumber: pr.number,
-      wisdomUnitsCreated: result.wisdom
+      wisdomUnitsCreated: result.wisdom,
+      regressionEventsCreated: result.regressions
     });
   }
   if (options.updateSyncStateAfter !== false) {
@@ -6292,6 +6579,18 @@ function parseGraphQLResponse(text, status, headers) {
     );
   }
 }
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isTransientGraphQLError(error) {
+  const status = error.status;
+  if (status === 502 || status === 503 || status === 504) return true;
+  const message = (error.message ?? "").toLowerCase();
+  return message.includes("fetch failed") || message.includes("econnreset") || message.includes("etimedout") || message.includes("socket hang up") || message.includes("network") || message.includes("non-json response") && (message.includes("text/html") || message.includes("<!doctype") || message.includes("<html") || typeof status === "number" && status >= 500);
+}
+function transientRetryDelayMs(attempt) {
+  return Math.min(4e3, 500 * 2 ** Math.max(0, attempt - 1));
+}
 function createGitHubGraphQLRequester(options) {
   if (!options.token.trim()) {
     throw new Error(
@@ -6303,36 +6602,55 @@ function createGitHubGraphQLRequester(options) {
   return async function requestGitHubGraphQL(query, variables, requestOptions) {
     return requestWithGitHubRateLimit(
       async () => {
-        const response = await fetchImpl("https://api.github.com/graphql", {
-          method: "POST",
-          headers: {
-            accept: "application/vnd.github+json",
-            authorization: `Bearer ${options.token}`,
-            "content-type": "application/json",
-            "user-agent": "anchor-local-mcp"
-          },
-          body: JSON.stringify({ query, variables })
-        });
-        const headers = headersToRecord(response.headers);
-        const raw = parseGraphQLResponse(await response.text(), response.status, headers);
-        if (!response.ok || raw.errors?.length) {
-          throw new GitHubGraphQLError(errorMessage(response.status, raw.errors), {
-            status: errorStatus(response.status, raw.errors),
-            headers
-          });
-        }
-        if (!raw.data) {
-          throw new GitHubGraphQLError("GitHub GraphQL response did not include data.", {
-            status: response.status,
-            headers
-          });
+        const maxAttempts = Math.max(1, requestOptions.maxTransientRetries ?? 3);
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+          try {
+            const response = await fetchImpl("https://api.github.com/graphql", {
+              method: "POST",
+              headers: {
+                accept: "application/vnd.github+json",
+                authorization: `Bearer ${options.token}`,
+                "content-type": "application/json",
+                "user-agent": "anchor-local-mcp"
+              },
+              body: JSON.stringify({ query, variables })
+            });
+            const headers = headersToRecord(response.headers);
+            const raw = parseGraphQLResponse(await response.text(), response.status, headers);
+            if (!response.ok || raw.errors?.length) {
+              throw new GitHubGraphQLError(errorMessage(response.status, raw.errors), {
+                status: errorStatus(response.status, raw.errors),
+                headers
+              });
+            }
+            if (!raw.data) {
+              throw new GitHubGraphQLError("GitHub GraphQL response did not include data.", {
+                status: response.status,
+                headers
+              });
+            }
+            updateGitHubGraphQLRateLimitState(
+              requestOptions.controller,
+              raw.data.rateLimit,
+              requestOptions.requestName
+            );
+            return { data: raw.data, headers };
+          } catch (error) {
+            if (attempt >= maxAttempts || !isTransientGraphQLError(error)) throw error;
+            const waitMs = transientRetryDelayMs(attempt);
+            requestOptions.onTransientRetry?.({
+              attempt,
+              maxAttempts,
+              waitMs,
+              reason: error instanceof Error ? error.message : String(error)
+            });
+            await sleep2(waitMs);
+          }
         }
-        updateGitHubGraphQLRateLimitState(
-          requestOptions.controller,
-          raw.data.rateLimit,
-          requestOptions.requestName
-        );
-        return { data: raw.data, headers };
+        throw new GitHubGraphQLError("GitHub GraphQL request retry loop exited unexpectedly.", {
+          status: 500,
+          headers: {}
+        });
       },
       {
         controller: requestOptions.controller,
@@ -6518,6 +6836,16 @@ var GraphQLBudget = class {
     };
   }
 };
+function graphqlRetryProgress(repo, onProgress) {
+  return (retry) => onProgress?.({
+    stage: "github_graphql_retry",
+    repo,
+    attempt: retry.attempt,
+    maxAttempts: retry.maxAttempts,
+    waitMs: retry.waitMs,
+    reason: retry.reason
+  });
+}
 var PULL_REQUEST_FIELDS = `
   number
   url
@@ -6655,7 +6983,8 @@ function connectionNodes(connection) {
 async function requestGraphQLWithBudget(requestGraphQL, query, variables, options) {
   const response = await requestGraphQL(query, variables, {
     controller: options.controller,
-    requestName: options.requestName
+    requestName: options.requestName,
+    onTransientRetry: options.onTransientRetry
   });
   options.budget.observe(response.data.rateLimit);
   return response;
@@ -6741,7 +7070,8 @@ async function appendAdditionalFiles(requestGraphQL, record, initialConnection,
       {
         controller: options.controller,
         requestName: `GraphQL /repos/${record.repo}/pulls/${record.number}/files`,
-        budget: options.budget
+        budget: options.budget,
+        onTransientRetry: options.onTransientRetry
       }
     );
     record.files.push(
@@ -6767,7 +7097,8 @@ async function appendAdditionalIssueComments(requestGraphQL, record, initialConn
       {
         controller: options.controller,
         requestName: `GraphQL /repos/${record.repo}/issues/${record.number}/comments`,
-        budget: options.budget
+        budget: options.budget,
+        onTransientRetry: options.onTransientRetry
       }
     );
     record.issueComments?.push(...connectionNodes(connection).map(mapIssueComment));
@@ -6791,7 +7122,8 @@ async function appendAdditionalCommits(requestGraphQL, record, initialConnection
       {
         controller: options.controller,
         requestName: `GraphQL /repos/${record.repo}/pulls/${record.number}/commits`,
-        budget: options.budget
+        budget: options.budget,
+        onTransientRetry: options.onTransientRetry
       }
     );
     record.commits?.push(
@@ -6816,7 +7148,8 @@ async function appendAdditionalReviewComments(requestGraphQL, record, review, op
       {
         controller: options.controller,
         requestName: `GraphQL /pull-request-reviews/${review.id}/comments`,
-        budget: options.budget
+        budget: options.budget,
+        onTransientRetry: options.onTransientRetry
       }
     );
     const connection = response.data.node?.comments;
@@ -6842,7 +7175,8 @@ async function appendAdditionalReviews(requestGraphQL, record, initialConnection
       {
         controller: options.controller,
         requestName: `GraphQL /repos/${record.repo}/pulls/${record.number}/reviews`,
-        budget: options.budget
+        budget: options.budget,
+        onTransientRetry: options.onTransientRetry
       }
     );
     const reviewNodes = connectionNodes(connection);
@@ -6856,7 +7190,8 @@ async function appendAdditionalReviews(requestGraphQL, record, initialConnection
   for (const review of reviewsToHydrate) {
     await appendAdditionalReviewComments(requestGraphQL, record, review, {
       controller: options.controller,
-      budget: options.budget
+      budget: options.budget,
+      onTransientRetry: options.onTransientRetry
     });
   }
 }
@@ -7012,6 +7347,7 @@ async function fetchMergedPullRequestsWithGraphQL(options) {
     checkpoint?.pageSize ?? Math.min(INITIAL_PULL_REQUEST_PAGE_SIZE, options.limit ?? INITIAL_PULL_REQUEST_PAGE_SIZE)
   );
   const budget = new GraphQLBudget(GRAPHQL_RATE_LIMIT_RESERVE);
+  const onTransientRetry = graphqlRetryProgress(options.repo, options.onProgress);
   const checkpointScope = checkpoint?.scope ?? `${options.repo}|${options.limit === void 0 ? "all" : `limit:${options.limit}`}|since:${options.since ?? ""}`;
   options.onProgress?.({
     stage: "discovering_pull_requests",
@@ -7038,7 +7374,8 @@ async function fetchMergedPullRequestsWithGraphQL(options) {
     {
       controller: options.controller,
       requestName: "GraphQL rate limit preflight",
-      budget
+      budget,
+      onTransientRetry
     }
   );
   const preflightRateLimit = budget.rateLimit();
@@ -7100,7 +7437,8 @@ async function fetchMergedPullRequestsWithGraphQL(options) {
         {
           controller: options.controller,
           requestName: `GraphQL /repos/${options.repo}/pullRequests`,
-          budget
+          budget,
+          onTransientRetry
         }
       );
     } catch (error) {
@@ -7131,7 +7469,8 @@ async function fetchMergedPullRequestsWithGraphQL(options) {
         owner,
         name,
         controller: options.controller,
-        budget
+        budget,
+        onTransientRetry
       });
       records.push(record);
       if (options.limit !== void 0 && records.length >= options.limit) break;
@@ -7553,6 +7892,9 @@ function openOrgDatabase(org, baseDir) {
   initializeSchema(db);
   return db;
 }
+function openOrgDatabaseReadOnly(org, baseDir) {
+  return openAnchorDatabaseReadOnly(orgDatabasePath(org, baseDir));
+}
 function syncOrgConfigToDatabase(db, config, baseDir) {
   initializeSchema(db);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -7730,9 +8072,11 @@ function grade(score) {
   if (score < 80) return "good";
   return "excellent";
 }
-function getOrgStatus(db, config, baseDir) {
-  initializeSchema(db);
-  syncOrgConfigToDatabase(db, config, baseDir);
+function getOrgStatus(db, config, baseDir, options = {}) {
+  if (options.syncConfig !== false) {
+    initializeSchema(db);
+    syncOrgConfigToDatabase(db, config, baseDir);
+  }
   const enabledRepos = config.repos.filter((repo) => repo.enabled);
   const states = new Map(
     db.prepare("SELECT * FROM org_repo_state WHERE org = ?").all(config.org).map((row) => [row.repo, row])
@@ -7779,6 +8123,8 @@ function getOrgStatus(db, config, baseDir) {
     org: config.org,
     root: orgRoot(config.org, baseDir),
     databasePath: orgDatabasePath(config.org, baseDir),
+    statusReadError: options.statusReadError,
+    activeRun: options.activeRun,
     repoCount: config.repos.length,
     enabledRepoCount: enabledRepos.length,
     clonedRepoCount,
@@ -7813,10 +8159,141 @@ function getOrgStatus(db, config, baseDir) {
   };
 }
 
-// src/org/clone.ts
-import { execFileSync as execFileSync4 } from "child_process";
+// src/org/heartbeat.ts
 import fs11 from "fs";
 import path21 from "path";
+var HEARTBEAT_STALE_AFTER_MS = 2 * 60 * 1e3;
+function orgHeartbeatPath(org, baseDir) {
+  return path21.join(orgRoot(validateOrgName(org), baseDir), "sync-heartbeat.json");
+}
+function atomicWriteJson2(filePath, value) {
+  fs11.mkdirSync(path21.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs11.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  fs11.renameSync(tmp, filePath);
+}
+function processIsRunning(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseHeartbeat(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const candidate = value;
+  if (typeof candidate.pid !== "number" || typeof candidate.command !== "string" || typeof candidate.org !== "string" || typeof candidate.phase !== "string" || typeof candidate.startedAt !== "string" || typeof candidate.updatedAt !== "string") {
+    return void 0;
+  }
+  return {
+    pid: candidate.pid,
+    command: candidate.command,
+    org: candidate.org,
+    repo: typeof candidate.repo === "string" ? candidate.repo : void 0,
+    repoIndex: typeof candidate.repoIndex === "number" ? candidate.repoIndex : void 0,
+    repoTotal: typeof candidate.repoTotal === "number" ? candidate.repoTotal : void 0,
+    phase: candidate.phase,
+    timeline: parseTimeline(candidate.timeline),
+    startedAt: candidate.startedAt,
+    updatedAt: candidate.updatedAt
+  };
+}
+function parseTimelineStatus(value) {
+  if (value === "active" || value === "done" || value === "skipped" || value === "warn" || value === "fail" || value === "wait") {
+    return value;
+  }
+  return void 0;
+}
+function parseTimelineNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseTimelineStep(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const candidate = value;
+  const status = parseTimelineStatus(candidate.status);
+  if (typeof candidate.id !== "string" || typeof candidate.label !== "string" || !status || typeof candidate.startedAt !== "string" || typeof candidate.updatedAt !== "string") {
+    return void 0;
+  }
+  return {
+    id: candidate.id,
+    label: candidate.label,
+    status,
+    startedAt: candidate.startedAt,
+    updatedAt: candidate.updatedAt,
+    completedAt: typeof candidate.completedAt === "string" ? candidate.completedAt : void 0,
+    durationMs: parseTimelineNumber(candidate.durationMs),
+    current: parseTimelineNumber(candidate.current),
+    total: parseTimelineNumber(candidate.total),
+    detail: typeof candidate.detail === "string" ? candidate.detail : void 0
+  };
+}
+function parseTimelineRepoSummary(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const candidate = value;
+  const status = parseTimelineStatus(candidate.status);
+  if (typeof candidate.repo !== "string" || !status) return void 0;
+  return {
+    repo: candidate.repo,
+    status,
+    durationMs: parseTimelineNumber(candidate.durationMs) ?? 0,
+    detail: typeof candidate.detail === "string" ? candidate.detail : void 0
+  };
+}
+function parseTimeline(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const candidate = value;
+  if (!Array.isArray(candidate.steps) || !Array.isArray(candidate.recentRepos)) return void 0;
+  const steps = candidate.steps.map(parseTimelineStep).filter((step) => step !== void 0);
+  const recentRepos = candidate.recentRepos.map(parseTimelineRepoSummary).filter((repo) => repo !== void 0);
+  return {
+    repo: typeof candidate.repo === "string" ? candidate.repo : void 0,
+    repoIndex: parseTimelineNumber(candidate.repoIndex),
+    repoTotal: parseTimelineNumber(candidate.repoTotal),
+    activeStepId: typeof candidate.activeStepId === "string" ? candidate.activeStepId : void 0,
+    steps,
+    recentRepos
+  };
+}
+function writeOrgHeartbeat(heartbeat, baseDir) {
+  atomicWriteJson2(orgHeartbeatPath(heartbeat.org, baseDir), heartbeat);
+}
+function clearOrgHeartbeat(org, baseDir) {
+  try {
+    const filePath = orgHeartbeatPath(org, baseDir);
+    if (fs11.existsSync(filePath)) fs11.unlinkSync(filePath);
+  } catch {
+  }
+}
+function readOrgHeartbeat(org, baseDir) {
+  const filePath = orgHeartbeatPath(org, baseDir);
+  if (!fs11.existsSync(filePath)) return void 0;
+  try {
+    const heartbeat = parseHeartbeat(JSON.parse(fs11.readFileSync(filePath, "utf8")));
+    if (!heartbeat) return void 0;
+    const now = Date.now();
+    const startedAtMs = Date.parse(heartbeat.startedAt);
+    const updatedAtMs = Date.parse(heartbeat.updatedAt);
+    const pidRunning = processIsRunning(heartbeat.pid);
+    const lastUpdateAgeSeconds = Number.isFinite(updatedAtMs) ? Math.max(0, Math.floor((now - updatedAtMs) / 1e3)) : 0;
+    return {
+      ...heartbeat,
+      pidRunning,
+      stale: !pidRunning || !Number.isFinite(updatedAtMs) || now - updatedAtMs > HEARTBEAT_STALE_AFTER_MS,
+      elapsedSeconds: Number.isFinite(startedAtMs) ? Math.max(0, Math.floor((now - startedAtMs) / 1e3)) : 0,
+      lastUpdateAgeSeconds
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/org/clone.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import fs12 from "fs";
+import path22 from "path";
 function defaultGitCommandRunner(command, args, options = {}) {
   return execFileSync4(command, args, {
     cwd: options.cwd,
@@ -7832,7 +8309,7 @@ function currentCommit(runner, localPath) {
   }
 }
 function plannedOrgCloneCommands(repo, localPath) {
-  if (!fs11.existsSync(path21.join(localPath, ".git"))) {
+  if (!fs12.existsSync(path22.join(localPath, ".git"))) {
     return [
       {
         command: "git",
@@ -7861,8 +8338,8 @@ function plannedOrgCloneCommands(repo, localPath) {
 function cloneOrPullOrgRepo(input) {
   const runner = input.runner ?? defaultGitCommandRunner;
   const localPath = orgRepoLocalPath(input.org, input.repo, input.baseDir);
-  const existed = fs11.existsSync(path21.join(localPath, ".git"));
-  fs11.mkdirSync(path21.dirname(localPath), { recursive: true });
+  const existed = fs12.existsSync(path22.join(localPath, ".git"));
+  fs12.mkdirSync(path22.dirname(localPath), { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   try {
     const commands = plannedOrgCloneCommands(input.repo, localPath);
@@ -7963,8 +8440,8 @@ function orgCloneStateFromResult(org, repo, result) {
 
 // src/org/graph.ts
 import crypto9 from "crypto";
-import fs12 from "fs";
-import path22 from "path";
+import fs13 from "fs";
+import path23 from "path";
 function stableId(parts) {
   return crypto9.createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
 }
@@ -7978,10 +8455,10 @@ function fileEvidence(repo, filePath, note) {
   };
 }
 function readPackageManifest(repoPath) {
-  const packagePath = path22.join(repoPath, "package.json");
-  if (!fs12.existsSync(packagePath)) return void 0;
+  const packagePath = path23.join(repoPath, "package.json");
+  if (!fs13.existsSync(packagePath)) return void 0;
   try {
-    return JSON.parse(fs12.readFileSync(packagePath, "utf8"));
+    return JSON.parse(fs13.readFileSync(packagePath, "utf8"));
   } catch {
     return void 0;
   }
@@ -8041,7 +8518,7 @@ function isApiConsumerText(text) {
 function evidenceJson(evidence) {
   return JSON.stringify(evidence);
 }
-function shouldEmitProgress(current, total, interval = 100) {
+function shouldEmitProgress2(current, total, interval = 100) {
   return current === 1 || current === total || current % interval === 0;
 }
 function resolveOptions(baseDirOrOptions) {
@@ -8147,7 +8624,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
         });
         break;
       }
-      if (shouldEmitProgress(index + 1, imports.length)) {
+      if (shouldEmitProgress2(index + 1, imports.length)) {
         options.onProgress?.({
           stage: "building_import_edges",
           org: config.org,
@@ -8188,7 +8665,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
         bucket.push(apiContract);
         contractsByToken.set(sanitizedContract, bucket);
       }
-      if (shouldEmitProgress(index + 1, providerChunks.length)) {
+      if (shouldEmitProgress2(index + 1, providerChunks.length)) {
         options.onProgress?.({
           stage: "extracting_api_contracts",
           org: config.org,
@@ -8248,7 +8725,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           });
         }
       }
-      if (shouldEmitProgress(index + 1, consumerChunks.length)) {
+      if (shouldEmitProgress2(index + 1, consumerChunks.length)) {
         options.onProgress?.({
           stage: "matching_api_consumers",
           org: config.org,
@@ -8274,7 +8751,11 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
       const insertEdge = db.prepare(
         `INSERT INTO org_cross_repo_edges
          (id, org, source_repo, source_path, target_repo, target_path, relationship, evidence_json, confidence, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           evidence_json = excluded.evidence_json,
+           confidence = excluded.confidence,
+           created_at = excluded.created_at`
       );
       for (const edge of edges) {
         insertEdge.run(
@@ -8293,7 +8774,12 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
       const insertContract = db.prepare(
         `INSERT INTO org_api_contracts
          (id, org, repo, file_path, contract, evidence_json, confidence, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           contract = excluded.contract,
+           evidence_json = excluded.evidence_json,
+           confidence = excluded.confidence,
+           created_at = excluded.created_at`
       );
       for (const contract of apiContracts) {
         insertContract.run(
@@ -8310,7 +8796,12 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
       const insertConsumer = db.prepare(
         `INSERT INTO org_api_consumers
          (id, org, provider_repo, provider_path, consumer_repo, consumer_path, contract, evidence_json, confidence, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           contract = excluded.contract,
+           evidence_json = excluded.evidence_json,
+           confidence = excluded.confidence,
+           created_at = excluded.created_at`
       );
       for (const consumer of apiConsumers) {
         insertConsumer.run(
@@ -8373,7 +8864,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
 }
 
 // src/org/index.ts
-import fs13 from "fs";
+import fs14 from "fs";
 var ORG_SYNC_RESUME_WINDOW_MS = 12 * 60 * 60 * 1e3;
 function readCommit(runner, cwd) {
   try {
@@ -8417,14 +8908,42 @@ async function indexOrgRepos(db, config, options = {}) {
   const auth = options.token ? { token: options.token } : resolveGitHubToken();
   const results = [];
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const startedAtMs = Date.now();
   const graphState = getOrgGraphState(db, config.org);
-  for (const repo of repos) {
+  const command = options.command ?? "org index";
+  const emit = (progress) => options.onLifecycleProgress?.(progress);
+  emit({
+    stage: "org_sync_started",
+    org: config.org,
+    command,
+    totalRepos: repos.length
+  });
+  for (const [repoIndex, repo] of repos.entries()) {
+    const repoPosition = repoIndex + 1;
     const localPath = orgRepoLocalPath(config.org, repo, options.baseDir);
     const repoStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const repoStartedAtMs = Date.now();
     let prsIndexed = 0;
     let codeFilesIndexed = 0;
     try {
-      if (!fs13.existsSync(localPath)) throw new Error(missingCloneError(repo.fullName, localPath));
+      emit({
+        stage: "org_repo_started",
+        org: config.org,
+        command,
+        repo: repo.fullName,
+        current: repoPosition,
+        total: repos.length
+      });
+      if (!fs14.existsSync(localPath)) throw new Error(missingCloneError(repo.fullName, localPath));
+      emit({
+        stage: "org_repo_phase",
+        org: config.org,
+        command,
+        repo: repo.fullName,
+        current: repoPosition,
+        total: repos.length,
+        phase: "Reading current commit"
+      });
       const currentCommit2 = readCommit(runner, localPath);
       const state = getOrgRepoState(db, config.org, repo.fullName);
       let history;
@@ -8442,6 +8961,15 @@ async function indexOrgRepos(db, config, options = {}) {
         })) {
           skippedHistory = true;
           historySkippedReason = "PR history already synced; resuming unfinished org graph/index work.";
+          emit({
+            stage: "org_repo_skipped_history",
+            org: config.org,
+            command,
+            repo: repo.fullName,
+            current: repoPosition,
+            total: repos.length,
+            reason: historySkippedReason
+          });
           options.onFetchProgress?.({
             stage: "skipped_pull_request_fetch",
             repo: repo.fullName,
@@ -8453,6 +8981,15 @@ async function indexOrgRepos(db, config, options = {}) {
           );
         } else {
           try {
+            emit({
+              stage: "org_repo_phase",
+              org: config.org,
+              command,
+              repo: repo.fullName,
+              current: repoPosition,
+              total: repos.length,
+              phase: "Fetching PR history"
+            });
             const since = options.since ?? (options.command === "org sync" ? state?.lastPrSyncAt ?? getLastSyncTime(db, repo.fullName) : void 0);
             const pullRequests = await fetchPullRequests({
               token: auth.token,
@@ -8462,6 +8999,16 @@ async function indexOrgRepos(db, config, options = {}) {
               detailConcurrency: options.concurrency,
               onProgress: options.onFetchProgress
             });
+            emit({
+              stage: "org_repo_phase",
+              org: config.org,
+              command,
+              repo: repo.fullName,
+              current: repoPosition,
+              total: repos.length,
+              phase: "Indexing PR history into SQLite",
+              detail: `${pullRequests.length} PR(s)`
+            });
             history = indexPullRequests(db, pullRequests, {
               cwd: localPath,
               repo: repo.fullName,
@@ -8486,6 +9033,15 @@ async function indexOrgRepos(db, config, options = {}) {
       }
       const codeUnchanged = !options.force && currentCommit2 && state?.lastCodeIndexedCommit && currentCommit2 === state.lastCodeIndexedCommit;
       if (!options.prsOnly && !codeUnchanged) {
+        emit({
+          stage: "org_repo_phase",
+          org: config.org,
+          command,
+          repo: repo.fullName,
+          current: repoPosition,
+          total: repos.length,
+          phase: "Indexing code and architecture"
+        });
         code = indexCodebase(db, {
           cwd: localPath,
           repo: repo.fullName,
@@ -8501,6 +9057,26 @@ async function indexOrgRepos(db, config, options = {}) {
           lastCodeIndexedCommit: currentCommit2,
           lastCodeIndexedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
+      } else if (!options.prsOnly && codeUnchanged) {
+        emit({
+          stage: "org_repo_skipped_code",
+          org: config.org,
+          command,
+          repo: repo.fullName,
+          current: repoPosition,
+          total: repos.length,
+          reason: "Code skipped: current commit already indexed."
+        });
+      } else if (options.prsOnly) {
+        emit({
+          stage: "org_repo_skipped_code",
+          org: config.org,
+          command,
+          repo: repo.fullName,
+          current: repoPosition,
+          total: repos.length,
+          reason: "Code skipped because --prs-only was passed."
+        });
       }
       if (repoFailures.length > 0) {
         updateOrgRepoState(db, {
@@ -8512,6 +9088,14 @@ async function indexOrgRepos(db, config, options = {}) {
           lastError: repoFailures.join("; ")
         });
       }
+      emit({
+        stage: "org_repo_finalizing",
+        org: config.org,
+        command,
+        repo: repo.fullName,
+        current: repoPosition,
+        total: repos.length
+      });
       results.push({
         repo: repo.fullName,
         skippedCode: Boolean(codeUnchanged || options.prsOnly),
@@ -8525,7 +9109,7 @@ async function indexOrgRepos(db, config, options = {}) {
       recordOrgIndexRun(db, {
         org: config.org,
         repo: repo.fullName,
-        command: options.command ?? "org index",
+        command,
         startedAt: repoStartedAt,
         finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
         status: repoFailures.length > 0 ? "partial" : "success",
@@ -8533,6 +9117,20 @@ async function indexOrgRepos(db, config, options = {}) {
         codeFilesIndexed,
         failures: repoFailures
       });
+      emit({
+        stage: "org_repo_completed",
+        org: config.org,
+        command,
+        repo: repo.fullName,
+        current: repoPosition,
+        total: repos.length,
+        skippedHistory,
+        skippedCode: Boolean(codeUnchanged || options.prsOnly),
+        prsIndexed,
+        codeFilesIndexed,
+        durationMs: Date.now() - repoStartedAtMs,
+        error: repoFailures.join("; ") || void 0
+      });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       updateOrgRepoState(db, {
@@ -8545,7 +9143,7 @@ async function indexOrgRepos(db, config, options = {}) {
       recordOrgIndexRun(db, {
         org: config.org,
         repo: repo.fullName,
-        command: options.command ?? "org index",
+        command,
         startedAt: repoStartedAt,
         finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
         status: "failed",
@@ -8556,6 +9154,20 @@ async function indexOrgRepos(db, config, options = {}) {
         skippedCode: false,
         error: message
       });
+      emit({
+        stage: "org_repo_completed",
+        org: config.org,
+        command,
+        repo: repo.fullName,
+        current: repoPosition,
+        total: repos.length,
+        skippedHistory: false,
+        skippedCode: false,
+        prsIndexed,
+        codeFilesIndexed,
+        durationMs: Date.now() - repoStartedAtMs,
+        error: message
+      });
     }
   }
   let graph;
@@ -8568,6 +9180,12 @@ async function indexOrgRepos(db, config, options = {}) {
       apiContractCount: counts.apiContracts,
       apiConsumerCount: counts.apiConsumers
     });
+    emit({
+      stage: "org_graph_skipped",
+      org: config.org,
+      command,
+      reason: "Graph skipped because --no-graph was passed."
+    });
     graph = { ...counts, skipped: true };
   } else {
     try {
@@ -8588,7 +9206,7 @@ async function indexOrgRepos(db, config, options = {}) {
   }
   recordOrgIndexRun(db, {
     org: config.org,
-    command: options.command ?? "org index",
+    command,
     startedAt,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
     status: results.some((result) => result.error) || graph.error ? "partial" : "success",
@@ -8596,6 +9214,15 @@ 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))
   });
+  emit({
+    stage: "org_sync_completed",
+    org: config.org,
+    command,
+    totalRepos: repos.length,
+    succeededRepos: results.filter((result) => !result.error).length,
+    failedRepos: results.filter((result) => result.error).length,
+    durationMs: Date.now() - startedAtMs
+  });
   return {
     org: config.org,
     repos: results.sort((a, b) => a.repo.localeCompare(b.repo)),
@@ -9220,8 +9847,8 @@ function isTestPath2(filePath) {
 }
 
 // src/doctor.ts
-import fs14 from "fs";
-import path23 from "path";
+import fs15 from "fs";
+import path24 from "path";
 function check(name, ok, message, fix) {
   return { name, ok, message, fix: ok ? void 0 : fix };
 }
@@ -9325,12 +9952,12 @@ async function runDoctor(options) {
       )
     );
   }
-  const cursorConfigPath = path23.join(gitRoot ?? cwd, ".cursor", "mcp.json");
+  const cursorConfigPath = path24.join(gitRoot ?? cwd, ".cursor", "mcp.json");
   let cursorConfig;
   let cursorConfigValid = false;
-  if (fs14.existsSync(cursorConfigPath)) {
+  if (fs15.existsSync(cursorConfigPath)) {
     try {
-      cursorConfig = JSON.parse(fs14.readFileSync(cursorConfigPath, "utf8"));
+      cursorConfig = JSON.parse(fs15.readFileSync(cursorConfigPath, "utf8"));
       cursorConfigValid = true;
     } catch {
       cursorConfigValid = false;
@@ -9339,7 +9966,7 @@ async function runDoctor(options) {
   checks.push(
     check(
       ".cursor/mcp.json valid",
-      fs14.existsSync(cursorConfigPath) && cursorConfigValid,
+      fs15.existsSync(cursorConfigPath) && cursorConfigValid,
       cursorConfigValid ? ".cursor/mcp.json exists and is valid JSON." : ".cursor/mcp.json is missing or invalid.",
       "Run anchor init. If the file is malformed, fix the JSON and rerun anchor init."
     )
@@ -9356,7 +9983,7 @@ async function runDoctor(options) {
     )
   );
   const dbPath = defaultDatabasePath(gitRoot ?? cwd);
-  const dbExists = fs14.existsSync(dbPath);
+  const dbExists = fs15.existsSync(dbPath);
   checks.push(
     check(
       ".anchor/index.sqlite exists",
@@ -9400,12 +10027,12 @@ async function runDoctor(options) {
       "Run pnpm build, then try anchor serve from the repository."
     )
   );
-  const rulePath = path23.join(gitRoot ?? cwd, ".cursor", "rules", "anchor.mdc");
+  const rulePath = path24.join(gitRoot ?? cwd, ".cursor", "rules", "anchor.mdc");
   checks.push(
     check(
       "Cursor rule file exists",
-      fs14.existsSync(rulePath),
-      fs14.existsSync(rulePath) ? "Cursor rule file exists." : "Cursor rule file is missing.",
+      fs15.existsSync(rulePath),
+      fs15.existsSync(rulePath) ? "Cursor rule file exists." : "Cursor rule file is missing.",
       "Run anchor init to create .cursor/rules/anchor.mdc."
     )
   );
@@ -9482,6 +10109,7 @@ export {
   clampMaxResults,
   classifyArchitectureArea,
   clearGraphQLFetchCheckpoint,
+  clearOrgHeartbeat,
   clipSentence,
   cloneOrPullOrgRepo,
   cloneOrgRepos,
@@ -9568,10 +10196,13 @@ export {
   mergeAnchorMcpConfig,
   normalizePullRequest,
   openAnchorDatabase,
+  openAnchorDatabaseReadOnly,
   openOrgDatabase,
+  openOrgDatabaseReadOnly,
   orgCloneStateFromResult,
   orgConfigPath,
   orgDatabasePath,
+  orgHeartbeatPath,
   orgRepoLocalPath,
   orgReposRoot,
   orgRoot,
@@ -9585,6 +10216,7 @@ export {
   rankRelevantTests,
   rankTeamRules,
   rankWisdomUnits,
+  readOrgHeartbeat,
   rebuildOrgGraph,
   recordFeedback,
   recordIndexRun,
@@ -9628,6 +10260,7 @@ export {
   validateOrgRepoFullName,
   validateOrgRepoGroup,
   validateTeamRulesFile,
-  watchCodebase
+  watchCodebase,
+  writeOrgHeartbeat
 };
 //# sourceMappingURL=index.js.map