@pratik7368patil/anchor-core 0.1.22 → 0.1.24

package/dist/index.js

@@ -1541,10 +1541,17 @@ function defaultDatabasePath(cwd) {
 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");
@@ -3101,6 +3108,18 @@ function indexCodebase(db, options) {
     architecture
   );
   refreshTestCommands(db, options.cwd, options.repo);
+  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 +3444,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 +6312,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 +6335,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 +6569,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 +6716,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 +6803,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 +6830,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 +6855,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 +6881,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 +6908,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 +6923,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 +7080,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 +7107,8 @@ async function fetchMergedPullRequestsWithGraphQL(options) {
     {
       controller: options.controller,
       requestName: "GraphQL rate limit preflight",
-      budget
+      budget,
+      onTransientRetry
     }
   );
   const preflightRateLimit = budget.rateLimit();
@@ -7100,7 +7170,8 @@ async function fetchMergedPullRequestsWithGraphQL(options) {
         {
           controller: options.controller,
           requestName: `GraphQL /repos/${options.repo}/pullRequests`,
-          budget
+          budget,
+          onTransientRetry
         }
       );
     } catch (error) {
@@ -7131,7 +7202,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 +7625,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();
@@ -7696,6 +7771,21 @@ function recordOrgGraphState(db, input) {
     now
   );
 }
+function getOrgGraphState(db, org) {
+  initializeSchema(db);
+  const row = db.prepare("SELECT * FROM org_graph_state WHERE org = ?").get(org);
+  if (!row) return void 0;
+  return {
+    org: row.org,
+    lastBuiltAt: row.last_built_at ?? void 0,
+    lastStatus: row.last_status ?? void 0,
+    lastDurationMs: row.last_duration_ms ?? void 0,
+    edgeCount: row.edge_count ?? void 0,
+    apiContractCount: row.api_contract_count ?? void 0,
+    apiConsumerCount: row.api_consumer_count ?? void 0,
+    lastError: row.last_error ?? void 0
+  };
+}
 function count(db, table, where = "", params = []) {
   const row = db.prepare(`SELECT COUNT(*) AS count FROM ${table} ${where}`).get(...params);
   return row.count;
@@ -7715,9 +7805,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])
@@ -7764,6 +7856,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,
@@ -7798,10 +7892,84 @@ 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,
+    startedAt: candidate.startedAt,
+    updatedAt: candidate.updatedAt
+  };
+}
+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,
@@ -7817,7 +7985,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",
@@ -7846,8 +8014,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);
@@ -7948,8 +8116,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);
 }
@@ -7963,10 +8131,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;
   }
@@ -8259,7 +8427,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(
@@ -8278,7 +8450,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(
@@ -8295,7 +8472,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(
@@ -8358,7 +8540,8 @@ 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 {
     return runner("git", ["rev-parse", "HEAD"], { cwd });
@@ -8369,6 +8552,27 @@ function readCommit(runner, cwd) {
 function missingCloneError(repo, localPath) {
   return `Repo ${repo} is not cloned at ${localPath}. Run anchor org clone --repo ${repo} --org <org>.`;
 }
+function latestIsoDate(dates) {
+  return dates.filter((date) => Boolean(date)).sort().at(-1);
+}
+function graphIsFreshForState(input) {
+  const latestRepoIndexAt = latestIsoDate([input.lastPrSyncAt, input.lastCodeIndexedAt]);
+  return Boolean(
+    latestRepoIndexAt && input.graphStatus === "success" && input.graphBuiltAt && input.graphBuiltAt >= latestRepoIndexAt
+  );
+}
+function isWithinResumeWindow(date) {
+  const parsed = Date.parse(date);
+  return Number.isFinite(parsed) && Date.now() - parsed <= ORG_SYNC_RESUME_WINDOW_MS;
+}
+function shouldSkipPrFetchForResume(input) {
+  if (input.options.command !== "org sync") return false;
+  if (input.options.force || input.options.since || input.options.noGraph) return false;
+  if (input.options.codeOnly || input.options.prsOnly) return false;
+  if (!input.lastPrSyncAt) return false;
+  if (!isWithinResumeWindow(input.lastPrSyncAt)) return false;
+  return !graphIsFreshForState(input);
+}
 async function indexOrgRepos(db, config, options = {}) {
   initializeSchema(db);
   syncOrgConfigToDatabase(db, config, options.baseDir);
@@ -8376,30 +8580,94 @@ async function indexOrgRepos(db, config, options = {}) {
     (repo) => repo.enabled && (!options.repo || repo.fullName === options.repo)
   );
   const runner = options.runner ?? defaultGitCommandRunner;
+  const fetchPullRequests = options.fetchPullRequests ?? fetchMergedPullRequests;
   const auth = options.token ? { token: options.token } : resolveGitHubToken();
   const results = [];
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  for (const repo of repos) {
+  const startedAtMs = Date.now();
+  const graphState = getOrgGraphState(db, config.org);
+  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;
       let code;
+      let skippedHistory = false;
+      let historySkippedReason;
       const repoFailures = [];
       if (!options.codeOnly) {
-        if (!auth.token) {
+        if (shouldSkipPrFetchForResume({
+          options,
+          lastPrSyncAt: state?.lastPrSyncAt,
+          lastCodeIndexedAt: state?.lastCodeIndexedAt,
+          graphBuiltAt: graphState?.lastBuiltAt,
+          graphStatus: graphState?.lastStatus
+        })) {
+          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,
+            reason: historySkippedReason
+          });
+        } else if (!auth.token) {
           repoFailures.push(
             "GitHub authentication is required for org PR indexing. Run gh auth login, or export GITHUB_TOKEN/GH_TOKEN with read-only access."
           );
         } 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 fetchMergedPullRequests({
+            const pullRequests = await fetchPullRequests({
               token: auth.token,
               repo: repo.fullName,
               limit: 200,
@@ -8407,6 +8675,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,
@@ -8431,6 +8709,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,
@@ -8446,6 +8733,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, {
@@ -8457,9 +8764,19 @@ 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),
+        skippedHistory,
+        historySkippedReason,
         currentCommit: currentCommit2,
         history,
         code,
@@ -8468,7 +8785,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",
@@ -8476,6 +8793,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, {
@@ -8488,7 +8819,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",
@@ -8499,6 +8830,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;
@@ -8511,6 +8856,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 {
@@ -8531,7 +8882,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",
@@ -8539,6 +8890,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)),
@@ -9163,8 +9523,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 };
 }
@@ -9268,12 +9628,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;
@@ -9282,7 +9642,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."
     )
@@ -9299,7 +9659,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",
@@ -9343,12 +9703,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."
     )
   );
@@ -9425,6 +9785,7 @@ export {
   clampMaxResults,
   classifyArchitectureArea,
   clearGraphQLFetchCheckpoint,
+  clearOrgHeartbeat,
   clipSentence,
   cloneOrPullOrgRepo,
   cloneOrgRepos,
@@ -9478,6 +9839,7 @@ export {
   getLastSyncTime,
   getOrgArchitectureMap,
   getOrgGraphCounts,
+  getOrgGraphState,
   getOrgRepoState,
   getOrgStatus,
   getPlaybook,
@@ -9510,10 +9872,13 @@ export {
   mergeAnchorMcpConfig,
   normalizePullRequest,
   openAnchorDatabase,
+  openAnchorDatabaseReadOnly,
   openOrgDatabase,
+  openOrgDatabaseReadOnly,
   orgCloneStateFromResult,
   orgConfigPath,
   orgDatabasePath,
+  orgHeartbeatPath,
   orgRepoLocalPath,
   orgReposRoot,
   orgRoot,
@@ -9527,6 +9892,7 @@ export {
   rankRelevantTests,
   rankTeamRules,
   rankWisdomUnits,
+  readOrgHeartbeat,
   rebuildOrgGraph,
   recordFeedback,
   recordIndexRun,
@@ -9570,6 +9936,7 @@ export {
   validateOrgRepoFullName,
   validateOrgRepoGroup,
   validateTeamRulesFile,
-  watchCodebase
+  watchCodebase,
+  writeOrgHeartbeat
 };
 //# sourceMappingURL=index.js.map