@pratik7368patil/anchor-core 0.1.21 → 0.1.23

package/dist/index.js

@@ -657,6 +657,18 @@ CREATE TABLE IF NOT EXISTS org_anomaly_events (
   created_at TEXT NOT NULL
 );
 
+CREATE TABLE IF NOT EXISTS org_graph_state (
+  org TEXT PRIMARY KEY,
+  last_built_at TEXT,
+  last_status TEXT NOT NULL DEFAULT 'unknown',
+  last_duration_ms INTEGER,
+  edge_count INTEGER NOT NULL DEFAULT 0,
+  api_contract_count INTEGER NOT NULL DEFAULT 0,
+  api_consumer_count INTEGER NOT NULL DEFAULT 0,
+  last_error TEXT,
+  updated_at TEXT NOT NULL
+);
+
 CREATE TABLE IF NOT EXISTS org_sync_checkpoints (
   org TEXT NOT NULL,
   repo TEXT NOT NULL,
@@ -694,6 +706,7 @@ CREATE INDEX IF NOT EXISTS idx_org_edges_target ON org_cross_repo_edges(org, tar
 CREATE INDEX IF NOT EXISTS idx_org_consumers_provider ON org_api_consumers(org, provider_repo);
 CREATE INDEX IF NOT EXISTS idx_org_consumers_consumer ON org_api_consumers(org, consumer_repo);
 CREATE INDEX IF NOT EXISTS idx_org_anomalies_org ON org_anomaly_events(org, severity);
+CREATE INDEX IF NOT EXISTS idx_org_graph_state_status ON org_graph_state(org, last_status);
 `;
 
 // src/rules/team-rules.ts
@@ -1573,7 +1586,8 @@ function checkSchema(db) {
       "org_repo_state",
       "org_cross_repo_edges",
       "org_api_consumers",
-      "org_anomaly_events"
+      "org_anomaly_events",
+      "org_graph_state"
     ].every(
       (tableName) => db.prepare("SELECT name FROM sqlite_master WHERE name = ?").all(tableName).length > 0
     );
@@ -7653,10 +7667,62 @@ function recordOrgIndexRun(db, input) {
     JSON.stringify(input.failures ?? [])
   );
 }
+function recordOrgGraphState(db, input) {
+  initializeSchema(db);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT INTO org_graph_state
+     (org, last_built_at, last_status, last_duration_ms, edge_count, api_contract_count,
+      api_consumer_count, last_error, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(org) DO UPDATE SET
+       last_built_at = COALESCE(excluded.last_built_at, org_graph_state.last_built_at),
+       last_status = excluded.last_status,
+       last_duration_ms = COALESCE(excluded.last_duration_ms, org_graph_state.last_duration_ms),
+       edge_count = excluded.edge_count,
+       api_contract_count = excluded.api_contract_count,
+       api_consumer_count = excluded.api_consumer_count,
+       last_error = excluded.last_error,
+       updated_at = excluded.updated_at`
+  ).run(
+    input.org,
+    input.builtAt ?? null,
+    input.status,
+    input.durationMs ?? null,
+    input.edgeCount ?? 0,
+    input.apiContractCount ?? 0,
+    input.apiConsumerCount ?? 0,
+    input.error ?? null,
+    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;
 }
+function getOrgGraphCounts(db, org) {
+  initializeSchema(db);
+  return {
+    edges: count(db, "org_cross_repo_edges", "WHERE org = ?", [org]),
+    apiContracts: count(db, "org_api_contracts", "WHERE org = ?", [org]),
+    apiConsumers: count(db, "org_api_consumers", "WHERE org = ?", [org])
+  };
+}
 function grade(score) {
   if (score <= 0) return "empty";
   if (score < 35) return "poor";
@@ -7678,8 +7744,10 @@ function getOrgStatus(db, config, baseDir) {
   const codeChunkCount = count(db, "code_chunks");
   const wisdomUnitCount = count(db, "wisdom_units");
   const crossRepoEdgeCount = count(db, "org_cross_repo_edges", "WHERE org = ?", [config.org]);
+  const apiContractCount = count(db, "org_api_contracts", "WHERE org = ?", [config.org]);
   const apiConsumerCount = count(db, "org_api_consumers", "WHERE org = ?", [config.org]);
   const anomalyCount = count(db, "org_anomaly_events", "WHERE org = ?", [config.org]);
+  const graphState = db.prepare("SELECT * FROM org_graph_state WHERE org = ?").get(config.org);
   let score = 0;
   const reasons = [];
   if (enabledRepos.length > 0) {
@@ -7718,8 +7786,13 @@ function getOrgStatus(db, config, baseDir) {
     codeChunkCount,
     wisdomUnitCount,
     crossRepoEdgeCount,
+    apiContractCount,
     apiConsumerCount,
     anomalyCount,
+    graphLastBuiltAt: graphState?.last_built_at ?? void 0,
+    graphLastStatus: graphState?.last_status ?? void 0,
+    graphLastDurationMs: graphState?.last_duration_ms ?? void 0,
+    graphLastError: graphState?.last_error ?? void 0,
     coverageScore: score,
     coverageGrade: grade(score),
     coverageReasons: reasons,
@@ -7845,16 +7918,32 @@ async function cloneOrgRepos(input) {
       const repo = repos[next];
       next += 1;
       if (!repo) continue;
-      input.onProgress?.(`cloning or pulling ${repo.fullName}`);
-      results.push(
-        cloneOrPullOrgRepo({
-          org: input.config.org,
-          repo,
-          db: input.db,
-          baseDir: input.baseDir,
-          runner: input.runner
-        })
-      );
+      const current = next;
+      input.onProgress?.({
+        stage: "cloning_or_pulling_repo",
+        org: input.config.org,
+        repo: repo.fullName,
+        current,
+        total: repos.length
+      });
+      const result = cloneOrPullOrgRepo({
+        org: input.config.org,
+        repo,
+        db: input.db,
+        baseDir: input.baseDir,
+        runner: input.runner
+      });
+      results.push(result);
+      input.onProgress?.({
+        stage: "cloned_or_pulled_repo",
+        org: input.config.org,
+        repo: repo.fullName,
+        current,
+        total: repos.length,
+        cloned: result.cloned,
+        pulled: result.pulled,
+        error: result.error
+      });
     }
   }
   await Promise.all(Array.from({ length: Math.min(limit, repos.length) }, () => worker()));
@@ -7952,210 +8041,340 @@ function isApiConsumerText(text) {
 function evidenceJson(evidence) {
   return JSON.stringify(evidence);
 }
-function rebuildOrgGraph(db, config, baseDir) {
+function shouldEmitProgress(current, total, interval = 100) {
+  return current === 1 || current === total || current % interval === 0;
+}
+function resolveOptions(baseDirOrOptions) {
+  return typeof baseDirOrOptions === "string" ? { baseDir: baseDirOrOptions } : baseDirOrOptions ?? {};
+}
+function rebuildOrgGraph(db, config, baseDirOrOptions) {
   initializeSchema(db);
-  const packageNames = repoPackageNames(config, baseDir);
-  const enabledRepos = config.repos.filter((repo) => repo.enabled);
-  const repoByName = new Map(enabledRepos.map((repo) => [repo.fullName, repo]));
-  const packageToRepo = /* @__PURE__ */ new Map();
-  for (const [repo, names] of packageNames.entries()) {
-    for (const name of names) packageToRepo.set(name, repo);
-  }
-  const edges = [];
-  const addEdge = (edge) => {
-    if (edge.sourceRepo === edge.targetRepo) return;
-    const key = [
-      edge.sourceRepo,
-      edge.sourcePath,
-      edge.targetRepo,
-      edge.targetPath ?? "",
-      edge.relationship
-    ].join("\0");
-    if (edges.some(
-      (existing) => [
-        existing.sourceRepo,
-        existing.sourcePath,
-        existing.targetRepo,
-        existing.targetPath ?? "",
-        existing.relationship
-      ].join("\0") === key
-    )) {
-      return;
-    }
-    edges.push(edge);
-  };
-  for (const repo of enabledRepos) {
-    const manifest = readPackageManifest(orgRepoLocalPath(config.org, repo, baseDir));
-    for (const dependency of dependenciesFor(manifest)) {
-      const targetRepo = packageToRepo.get(dependency);
-      if (!targetRepo || targetRepo === repo.fullName) continue;
-      addEdge({
-        org: config.org,
-        sourceRepo: repo.fullName,
-        sourcePath: "package.json",
-        targetRepo,
-        relationship: "depends_on_package",
-        evidence: [fileEvidence(repo.fullName, "package.json", `depends on ${dependency}`)],
-        confidence: 0.9
-      });
-    }
-  }
-  const imports = db.prepare(
-    `SELECT r.full_name AS repo, ci.source_path, ci.specifier, ci.imported_path, ci.imported_symbols_json
-       FROM code_imports ci
-       JOIN repositories r ON r.id = ci.repo_id`
-  ).all();
-  for (const item of imports) {
-    const sourceRepo = repoByName.get(item.repo);
-    if (!sourceRepo) continue;
-    for (const [targetRepo, names] of packageNames.entries()) {
-      if (targetRepo === item.repo) continue;
-      const matchedName = names.find(
-        (name) => item.specifier === name || item.specifier.startsWith(`${name}/`)
-      );
-      if (!matchedName) continue;
-      addEdge({
-        org: config.org,
-        sourceRepo: item.repo,
-        sourcePath: item.source_path,
-        targetRepo,
-        targetPath: item.imported_path ?? void 0,
-        relationship: "imports",
-        evidence: [
-          fileEvidence(
-            item.repo,
-            item.source_path,
-            `imports ${sanitizeHistoricalText(matchedName)}`
-          )
-        ],
-        confidence: parseJsonArray9(item.imported_symbols_json).length > 0 ? 0.88 : 0.76
-      });
-    }
-  }
-  const chunks = db.prepare(
-    `SELECT r.full_name AS repo, cc.file_path, cc.sanitized_text, cc.symbols_json
-       FROM code_chunks cc
-       JOIN repositories r ON r.id = cc.repo_id`
-  ).all();
-  const apiContracts = chunks.filter((chunk) => repoByName.has(chunk.repo) && isApiProviderPath(chunk.file_path)).flatMap(
-    (chunk) => extractContracts(chunk.sanitized_text).map((contract) => ({
-      repo: chunk.repo,
-      filePath: chunk.file_path,
-      contract,
-      evidence: [fileEvidence(chunk.repo, chunk.file_path, `defines ${contract}`)],
-      confidence: 0.74
-    }))
-  );
-  const apiConsumers = [];
-  for (const contract of apiContracts) {
-    for (const chunk of chunks) {
-      if (chunk.repo === contract.repo || !repoByName.has(chunk.repo)) continue;
-      if (!isApiConsumerText(chunk.sanitized_text)) continue;
-      if (!chunk.sanitized_text.includes(contract.contract)) continue;
-      const consumer = {
-        org: config.org,
-        providerRepo: contract.repo,
-        providerPath: contract.filePath,
-        consumerRepo: chunk.repo,
-        consumerPath: chunk.file_path,
-        contract: contract.contract,
-        evidence: [
-          ...contract.evidence,
-          fileEvidence(chunk.repo, chunk.file_path, `consumes ${contract.contract}`)
-        ],
-        confidence: 0.86
-      };
-      apiConsumers.push(consumer);
-      addEdge({
-        org: config.org,
-        sourceRepo: chunk.repo,
-        sourcePath: chunk.file_path,
-        targetRepo: contract.repo,
-        targetPath: contract.filePath,
-        relationship: "api_consumer",
-        evidence: consumer.evidence,
-        confidence: consumer.confidence
-      });
+  const options = resolveOptions(baseDirOrOptions);
+  const startedAt = Date.now();
+  try {
+    options.onProgress?.({
+      stage: "loading_package_manifests",
+      org: config.org,
+      totalRepos: config.repos.filter((repo) => repo.enabled).length
+    });
+    const packageNames = repoPackageNames(config, options.baseDir);
+    const enabledRepos = config.repos.filter((repo) => repo.enabled);
+    const repoByName = new Map(enabledRepos.map((repo) => [repo.fullName, repo]));
+    const packageToRepo = /* @__PURE__ */ new Map();
+    for (const [repo, names] of packageNames.entries()) {
+      for (const name of names) packageToRepo.set(name, repo);
     }
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const transaction = db.transaction(() => {
-    db.prepare("DELETE FROM org_cross_repo_edges WHERE org = ?").run(config.org);
-    db.prepare("DELETE FROM org_api_contracts WHERE org = ?").run(config.org);
-    db.prepare("DELETE FROM org_api_consumers WHERE org = ?").run(config.org);
-    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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    );
-    for (const edge of edges) {
-      insertEdge.run(
-        `oge_${stableId([edge.org, edge.sourceRepo, edge.sourcePath, edge.targetRepo, edge.targetPath ?? "", edge.relationship])}`,
-        edge.org,
+    options.onProgress?.({
+      stage: "loaded_package_manifests",
+      org: config.org,
+      repos: enabledRepos.length,
+      packageNames: packageToRepo.size
+    });
+    const edges = [];
+    const edgeKeys = /* @__PURE__ */ new Set();
+    const addEdge = (edge) => {
+      if (edge.sourceRepo === edge.targetRepo) return;
+      const key = [
         edge.sourceRepo,
         edge.sourcePath,
         edge.targetRepo,
-        edge.targetPath ?? null,
-        edge.relationship,
-        evidenceJson(edge.evidence),
-        edge.confidence,
-        now
-      );
-    }
-    const insertContract = db.prepare(
-      `INSERT INTO org_api_contracts
-       (id, org, repo, file_path, contract, evidence_json, confidence, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        edge.targetPath ?? "",
+        edge.relationship
+      ].join("\0");
+      if (edgeKeys.has(key)) return;
+      edgeKeys.add(key);
+      edges.push(edge);
+    };
+    enabledRepos.forEach((repo, index) => {
+      const manifest = readPackageManifest(orgRepoLocalPath(config.org, repo, options.baseDir));
+      for (const dependency of dependenciesFor(manifest)) {
+        const targetRepo = packageToRepo.get(dependency);
+        if (!targetRepo || targetRepo === repo.fullName) continue;
+        addEdge({
+          org: config.org,
+          sourceRepo: repo.fullName,
+          sourcePath: "package.json",
+          targetRepo,
+          relationship: "depends_on_package",
+          evidence: [
+            fileEvidence(
+              repo.fullName,
+              "package.json",
+              `depends on ${sanitizeHistoricalText(dependency)}`
+            )
+          ],
+          confidence: 0.9
+        });
+      }
+      options.onProgress?.({
+        stage: "building_package_edges",
+        org: config.org,
+        current: index + 1,
+        total: enabledRepos.length,
+        repo: repo.fullName,
+        edges: edges.length
+      });
+    });
+    options.onProgress?.({ stage: "loading_imports", org: config.org });
+    const imports = db.prepare(
+      `SELECT r.full_name AS repo, ci.source_path, ci.specifier, ci.imported_path, ci.imported_symbols_json
+         FROM code_imports ci
+         JOIN repositories r ON r.id = ci.repo_id`
+    ).all();
+    const packageMatchers = [...packageNames.entries()].flatMap(([repo, names]) => names.map((name) => ({ repo, name }))).sort((a, b) => b.name.length - a.name.length);
+    imports.forEach((item, index) => {
+      const sourceRepo = repoByName.get(item.repo);
+      if (!sourceRepo) return;
+      for (const candidate of packageMatchers) {
+        if (candidate.repo === item.repo) continue;
+        const matched = item.specifier === candidate.name || item.specifier.startsWith(`${candidate.name}/`);
+        if (!matched) continue;
+        addEdge({
+          org: config.org,
+          sourceRepo: item.repo,
+          sourcePath: item.source_path,
+          targetRepo: candidate.repo,
+          targetPath: item.imported_path ?? void 0,
+          relationship: "imports",
+          evidence: [
+            fileEvidence(
+              item.repo,
+              item.source_path,
+              `imports ${sanitizeHistoricalText(candidate.name)}`
+            )
+          ],
+          confidence: parseJsonArray9(item.imported_symbols_json).length > 0 ? 0.88 : 0.76
+        });
+        break;
+      }
+      if (shouldEmitProgress(index + 1, imports.length)) {
+        options.onProgress?.({
+          stage: "building_import_edges",
+          org: config.org,
+          current: index + 1,
+          total: imports.length,
+          sourcePath: item.source_path,
+          edges: edges.length
+        });
+      }
+    });
+    options.onProgress?.({ stage: "loading_code_chunks", org: config.org });
+    const chunks = db.prepare(
+      `SELECT r.full_name AS repo, cc.file_path, cc.sanitized_text, cc.symbols_json
+         FROM code_chunks cc
+         JOIN repositories r ON r.id = cc.repo_id`
+    ).all();
+    const providerChunks = chunks.filter(
+      (chunk) => repoByName.has(chunk.repo) && isApiProviderPath(chunk.file_path)
     );
-    for (const contract of apiContracts) {
-      insertContract.run(
-        `oac_${stableId([config.org, contract.repo, contract.filePath, contract.contract])}`,
-        config.org,
-        contract.repo,
-        contract.filePath,
-        sanitizeHistoricalText(contract.contract),
-        evidenceJson(contract.evidence),
-        contract.confidence,
-        now
-      );
-    }
-    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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    const apiContracts = [];
+    const contractKeys = /* @__PURE__ */ new Set();
+    const contractsByToken = /* @__PURE__ */ new Map();
+    providerChunks.forEach((chunk, index) => {
+      for (const contract of extractContracts(chunk.sanitized_text)) {
+        const sanitizedContract = sanitizeHistoricalText(contract);
+        const key = [chunk.repo, chunk.file_path, sanitizedContract].join("\0");
+        if (contractKeys.has(key)) continue;
+        contractKeys.add(key);
+        const apiContract = {
+          repo: chunk.repo,
+          filePath: chunk.file_path,
+          contract: sanitizedContract,
+          evidence: [fileEvidence(chunk.repo, chunk.file_path, `defines ${sanitizedContract}`)],
+          confidence: 0.74
+        };
+        apiContracts.push(apiContract);
+        const bucket = contractsByToken.get(sanitizedContract) ?? [];
+        bucket.push(apiContract);
+        contractsByToken.set(sanitizedContract, bucket);
+      }
+      if (shouldEmitProgress(index + 1, providerChunks.length)) {
+        options.onProgress?.({
+          stage: "extracting_api_contracts",
+          org: config.org,
+          current: index + 1,
+          total: providerChunks.length,
+          filePath: chunk.file_path,
+          contracts: apiContracts.length
+        });
+      }
+    });
+    const apiConsumers = [];
+    const consumerKeys = /* @__PURE__ */ new Set();
+    const consumerChunks = chunks.filter(
+      (chunk) => repoByName.has(chunk.repo) && isApiConsumerText(chunk.sanitized_text)
     );
-    for (const consumer of apiConsumers) {
-      insertConsumer.run(
-        `oap_${stableId([
+    consumerChunks.forEach((chunk, index) => {
+      const consumerTokens = extractContracts(chunk.sanitized_text);
+      let chunkMatches = 0;
+      for (const token of consumerTokens) {
+        const contracts = contractsByToken.get(sanitizeHistoricalText(token));
+        if (!contracts) continue;
+        for (const contract of contracts) {
+          if (chunk.repo === contract.repo) continue;
+          const consumerKey = [
+            contract.repo,
+            contract.filePath,
+            chunk.repo,
+            chunk.file_path,
+            contract.contract
+          ].join("\0");
+          if (consumerKeys.has(consumerKey)) continue;
+          consumerKeys.add(consumerKey);
+          const consumer = {
+            org: config.org,
+            providerRepo: contract.repo,
+            providerPath: contract.filePath,
+            consumerRepo: chunk.repo,
+            consumerPath: chunk.file_path,
+            contract: contract.contract,
+            evidence: [
+              ...contract.evidence,
+              fileEvidence(chunk.repo, chunk.file_path, `consumes ${contract.contract}`)
+            ],
+            confidence: 0.86
+          };
+          chunkMatches += 1;
+          apiConsumers.push(consumer);
+          addEdge({
+            org: config.org,
+            sourceRepo: chunk.repo,
+            sourcePath: chunk.file_path,
+            targetRepo: contract.repo,
+            targetPath: contract.filePath,
+            relationship: "api_consumer",
+            evidence: consumer.evidence,
+            confidence: consumer.confidence
+          });
+        }
+      }
+      if (shouldEmitProgress(index + 1, consumerChunks.length)) {
+        options.onProgress?.({
+          stage: "matching_api_consumers",
+          org: config.org,
+          current: index + 1,
+          total: consumerChunks.length,
+          filePath: chunk.file_path,
+          matches: chunkMatches
+        });
+      }
+    });
+    options.onProgress?.({
+      stage: "writing_org_graph",
+      org: config.org,
+      edges: edges.length,
+      apiContracts: apiContracts.length,
+      apiConsumers: apiConsumers.length
+    });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const transaction = db.transaction(() => {
+      db.prepare("DELETE FROM org_cross_repo_edges WHERE org = ?").run(config.org);
+      db.prepare("DELETE FROM org_api_contracts WHERE org = ?").run(config.org);
+      db.prepare("DELETE FROM org_api_consumers WHERE org = ?").run(config.org);
+      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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      );
+      for (const edge of edges) {
+        insertEdge.run(
+          `oge_${stableId([edge.org, edge.sourceRepo, edge.sourcePath, edge.targetRepo, edge.targetPath ?? "", edge.relationship])}`,
+          edge.org,
+          edge.sourceRepo,
+          edge.sourcePath,
+          edge.targetRepo,
+          edge.targetPath ?? null,
+          edge.relationship,
+          evidenceJson(edge.evidence),
+          edge.confidence,
+          now
+        );
+      }
+      const insertContract = db.prepare(
+        `INSERT INTO org_api_contracts
+         (id, org, repo, file_path, contract, evidence_json, confidence, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+      );
+      for (const contract of apiContracts) {
+        insertContract.run(
+          `oac_${stableId([config.org, contract.repo, contract.filePath, contract.contract])}`,
+          config.org,
+          contract.repo,
+          contract.filePath,
+          sanitizeHistoricalText(contract.contract),
+          evidenceJson(contract.evidence),
+          contract.confidence,
+          now
+        );
+      }
+      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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      );
+      for (const consumer of apiConsumers) {
+        insertConsumer.run(
+          `oap_${stableId([
+            consumer.org,
+            consumer.providerRepo,
+            consumer.providerPath ?? "",
+            consumer.consumerRepo,
+            consumer.consumerPath,
+            consumer.contract
+          ])}`,
           consumer.org,
           consumer.providerRepo,
-          consumer.providerPath ?? "",
+          consumer.providerPath ?? null,
           consumer.consumerRepo,
           consumer.consumerPath,
-          consumer.contract
-        ])}`,
-        consumer.org,
-        consumer.providerRepo,
-        consumer.providerPath ?? null,
-        consumer.consumerRepo,
-        consumer.consumerPath,
-        sanitizeHistoricalText(consumer.contract),
-        evidenceJson(consumer.evidence),
-        consumer.confidence,
-        now
-      );
-    }
-  });
-  transaction();
-  return {
-    edges,
-    apiConsumers,
-    apiContracts
-  };
+          sanitizeHistoricalText(consumer.contract),
+          evidenceJson(consumer.evidence),
+          consumer.confidence,
+          now
+        );
+      }
+    });
+    transaction();
+    const durationMs = Date.now() - startedAt;
+    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    recordOrgGraphState(db, {
+      org: config.org,
+      status: "success",
+      builtAt: finishedAt,
+      durationMs,
+      edgeCount: edges.length,
+      apiContractCount: apiContracts.length,
+      apiConsumerCount: apiConsumers.length
+    });
+    options.onProgress?.({
+      stage: "completed_org_graph",
+      org: config.org,
+      edges: edges.length,
+      apiContracts: apiContracts.length,
+      apiConsumers: apiConsumers.length,
+      durationMs
+    });
+    return {
+      edges,
+      apiConsumers,
+      apiContracts,
+      durationMs
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    recordOrgGraphState(db, {
+      org: config.org,
+      status: "failed",
+      durationMs: Date.now() - startedAt,
+      error: message
+    });
+    throw error;
+  }
 }
 
 // src/org/index.ts
 import fs13 from "fs";
+var ORG_SYNC_RESUME_WINDOW_MS = 12 * 60 * 60 * 1e3;
 function readCommit(runner, cwd) {
   try {
     return runner("git", ["rev-parse", "HEAD"], { cwd });
@@ -8166,6 +8385,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);
@@ -8173,9 +8413,11 @@ 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();
+  const graphState = getOrgGraphState(db, config.org);
   for (const repo of repos) {
     const localPath = orgRepoLocalPath(config.org, repo, options.baseDir);
     const repoStartedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -8187,16 +8429,32 @@ async function indexOrgRepos(db, config, options = {}) {
       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.";
+          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 {
             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,
@@ -8257,6 +8515,8 @@ async function indexOrgRepos(db, config, options = {}) {
       results.push({
         repo: repo.fullName,
         skippedCode: Boolean(codeUnchanged || options.prsOnly),
+        skippedHistory,
+        historySkippedReason,
         currentCommit: currentCommit2,
         history,
         code,
@@ -8298,25 +8558,48 @@ async function indexOrgRepos(db, config, options = {}) {
       });
     }
   }
-  const graph = rebuildOrgGraph(db, config, options.baseDir);
+  let graph;
+  if (options.noGraph) {
+    const counts = getOrgGraphCounts(db, config.org);
+    recordOrgGraphState(db, {
+      org: config.org,
+      status: "skipped",
+      edgeCount: counts.edges,
+      apiContractCount: counts.apiContracts,
+      apiConsumerCount: counts.apiConsumers
+    });
+    graph = { ...counts, skipped: true };
+  } else {
+    try {
+      const rebuiltGraph = rebuildOrgGraph(db, config, {
+        baseDir: options.baseDir,
+        onProgress: options.onGraphProgress
+      });
+      graph = {
+        edges: rebuiltGraph.edges.length,
+        apiConsumers: rebuiltGraph.apiConsumers.length,
+        apiContracts: rebuiltGraph.apiContracts.length
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const counts = getOrgGraphCounts(db, config.org);
+      graph = { ...counts, error: message };
+    }
+  }
   recordOrgIndexRun(db, {
     org: config.org,
     command: options.command ?? "org index",
     startedAt,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    status: results.some((result) => result.error) ? "partial" : "success",
+    status: results.some((result) => result.error) || graph.error ? "partial" : "success",
     prsIndexed: results.reduce((sum, result) => sum + (result.history?.indexedPrs ?? 0), 0),
     codeFilesIndexed: results.reduce((sum, result) => sum + (result.code?.indexedFiles ?? 0), 0),
-    failures: results.map((result) => result.error).filter((error) => Boolean(error))
+    failures: results.map((result) => result.error).concat(graph.error ? [graph.error] : []).filter((error) => Boolean(error))
   });
   return {
     org: config.org,
     repos: results.sort((a, b) => a.repo.localeCompare(b.repo)),
-    graph: {
-      edges: graph.edges.length,
-      apiConsumers: graph.apiConsumers.length,
-      apiContracts: graph.apiContracts.length
-    }
+    graph
   };
 }
 
@@ -9251,6 +9534,8 @@ export {
   getIndexStatus,
   getLastSyncTime,
   getOrgArchitectureMap,
+  getOrgGraphCounts,
+  getOrgGraphState,
   getOrgRepoState,
   getOrgStatus,
   getPlaybook,
@@ -9303,6 +9588,7 @@ export {
   rebuildOrgGraph,
   recordFeedback,
   recordIndexRun,
+  recordOrgGraphState,
   recordOrgIndexRun,
   redactSecrets,
   redactedHistoricalText,