perf(resolution): drop non-unique edge indexes during the bulk resolution window, byte-identical graphs

The resolution persist's measured cost is B-tree maintenance on the edges
table's five indexes (offline replay of a 224k-edge resolution set: 2.8s with
all indexes, 1.1s with only the unique identity index, +0.3s to recreate the
rest). On big runs (same >=150k-ref gate as the resolver pool) the four
non-unique edge indexes are now dropped for the batch loop and recreated in
one pass each before synthesis.

Why this is safe:
- idx_edges_identity stays: INSERT OR IGNORE's dedup conflicts on it (#1034),
  and its leftmost column is `source`, so the only mid-window edge reads —
  resolution's supertype walks (implements/extends by source) — keep an index
  via its prefix (verified with EXPLAIN QUERY PLAN).
- The window closes BEFORE synthesis, whose passes read kind-keyed, and on
  every error path (finally).
- A crash inside the window heals on the next DatabaseConnection open —
  schema.sql re-applies CREATE INDEX IF NOT EXISTS, same recovery as the FTS
  bulk-load pattern this mirrors.
- Concurrent readers (a daemon serving the project mid-index) stay correct;
  target/kind-keyed reads degrade to scans only for the window's duration.

dubbo (4,402 files): persists 4.0s -> 3.0s, fresh init 11.9s -> ~11.1s,
graph byte-identical. excalidraw (below the gate): untouched, byte-identical.
Recreation cost ~250ms, logged under CODEGRAPH_SYNTH_TIMINGS as
edge-index-recreate. Suite green (2444).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

CHANGELOG.md

@@ -14,6 +14,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - Reference resolution now runs in parallel on large projects. When a project has enough pending references to make it worthwhile (roughly 150k+, typical for big Java/Kotlin/Spring codebases), resolution fans out across worker threads while results are applied in the exact order the single-threaded path would have used — the graph comes out byte-for-byte identical, about twice as fast end-to-end on a 4,000-file Java project in our testing. Small projects keep the single-threaded path automatically (the fan-out costs more than it saves there). Set `CODEGRAPH_NO_PARALLEL_RESOLVE=1` to disable, or `CODEGRAPH_PARALLEL_RESOLVE_MIN=<count>` to tune when it engages.
 - Indexing large projects got another sizeable speedup — about a quarter less wall-clock on the same 4,000-file Java project, with the graph still byte-for-byte identical. Two changes: the database no longer interleaves expensive checkpoint housekeeping into the middle of resolution on a fresh index (it's folded once at the end instead), and while one batch's results are being written out, the worker threads are already resolving the next batch instead of sitting idle.
 - The dynamic-dispatch analysis that runs at the end of indexing (callback, event, and framework wiring) now runs its passes in parallel on large projects, cutting that stage roughly in half there — and a pass that crashes now retries safely instead of failing the whole index, which also makes very large codebases that previously died in this stage more likely to index to completion. Graphs remain byte-for-byte identical.
+- On large projects, indexing writes its relationship data noticeably faster: secondary database indexes are set aside during the bulk of reference resolution and rebuilt once at the end, instead of being maintained row by row. Graphs remain byte-for-byte identical, and small projects are unaffected.
 - Indexing is significantly faster — a fresh `codegraph init` on a medium TypeScript project takes about a third less wall-clock time, with the same graph produced byte-for-byte. The gains come from batching database writes, storing files on a dedicated writer thread, memoizing repeated import-resolution lookups, skipping per-row search-index maintenance during the bulk build (rebuilt once at the end), and — on completely fresh databases only — deferring disk durability until the index completes, since an interrupted first index is simply re-run. Set `CODEGRAPH_NO_FAST_INIT=1` to keep full crash-durability during the initial build, or `CODEGRAPH_NO_STORE_WORKER=1` to store on the main thread.
 - `codegraph install` and `codegraph upgrade` now offer CodeGraph Pro beta access after finishing — answer yes, type your email, and you join the same waitlist as the getcodegraph.com homepage form. Strictly opt-in and asked at most once per machine total: nothing is sent unless you say yes and enter an email, either answer is remembered so no later install or upgrade ever re-asks, and non-interactive runs (`--yes`, scripts, CI) never see the question.
 - Every release is now cryptographically verifiable: npm packages publish with npm provenance (the "Provenance" badge on npmjs.com, proving each version was built by this repository's release workflow from a specific commit), and the GitHub Release bundles carry signed build attestations you can check with `gh attestation verify <file> -R colbymchenry/codegraph`.

src/db/index.ts

@@ -151,6 +151,51 @@ export class DatabaseConnection {
     this.recreateFtsTriggers();
   }
 
+  /**
+   * Names of the NON-UNIQUE edge indexes dropped for a bulk edge load.
+   * idx_edges_identity deliberately stays: INSERT OR IGNORE's dedup conflicts
+   * on it (#1034), and its leftmost column is `source`, so the source-keyed
+   * reads resolution makes mid-window (supertype walks over
+   * `implements`/`extends`) keep an index via its prefix — verified with
+   * EXPLAIN QUERY PLAN. Target-keyed and kind-keyed reads (traversal,
+   * synthesis) happen only after endBulkEdgeLoad().
+   */
+  private static readonly BULK_EDGE_INDEX_NAMES = [
+    'idx_edges_kind',
+    'idx_edges_source_kind',
+    'idx_edges_target_kind',
+    'idx_edges_provenance',
+  ] as const;
+
+  /**
+   * Enter bulk-edge-load mode: drop the non-unique edge indexes so the mass
+   * INSERT OR IGNORE stream pays one B-tree (the identity index) instead of
+   * five — measured 2.8s → 1.1s inserting a 224k-edge resolution set, with
+   * recreation costing ~0.3s. MUST be paired with endBulkEdgeLoad(); a crash
+   * inside the window is healed on the next DatabaseConnection open (schema.sql
+   * re-applies CREATE INDEX IF NOT EXISTS).
+   */
+  beginBulkEdgeLoad(): void {
+    for (const idx of DatabaseConnection.BULK_EDGE_INDEX_NAMES) {
+      this.db.exec(`DROP INDEX IF EXISTS ${idx}`);
+    }
+  }
+
+  /**
+   * Leave bulk-edge-load mode: recreate the dropped indexes in one pass each
+   * over the (now fully loaded) edges table — far cheaper than maintaining
+   * them per-insert. DDL is extracted from schema.sql so it cannot drift.
+   */
+  endBulkEdgeLoad(): void {
+    const schemaPath = path.join(__dirname, 'schema.sql');
+    const schema = fs.readFileSync(schemaPath, 'utf-8');
+    for (const idx of DatabaseConnection.BULK_EDGE_INDEX_NAMES) {
+      const m = schema.match(new RegExp(`CREATE INDEX IF NOT EXISTS ${idx}\\b[^;]*;`));
+      if (!m) throw new Error(`schema.sql: edge index ${idx} not found for bulk-load recreation`);
+      this.db.exec(m[0]);
+    }
+  }
+
   /** Recreate the FTS triggers + rebuild if a bulk-load window never closed. */
   private healBulkNodeLoad(): void {
     const row = this.db

src/index.ts

@@ -1149,6 +1149,15 @@ export class CodeGraph {
   ): Promise<ResolutionResult> {
     return this.resolver.resolveAndPersistBatched(onProgress, undefined, onSynthesisProgress, {
       dbPath: this.db.getPath(),
+      // Bulk-edge-load hooks: on big runs the resolver drops the non-unique
+      // edge indexes for the batch loop and recreates them before synthesis
+      // (which reads kind-keyed). Concurrent readers (a daemon serving this
+      // project mid-index) stay CORRECT during the window — target/kind reads
+      // just degrade to scans until the recreate.
+      bulkEdgeLoad: {
+        begin: () => this.db.beginBulkEdgeLoad(),
+        end: () => this.db.endBulkEdgeLoad(),
+      },
     });
   }
 

src/resolution/index.ts

@@ -1336,8 +1336,10 @@ export class ReferenceResolver {
     // When provided, big batches fan out across a read-only resolver-worker
     // pool with results admitted in canonical order (see resolver-pool.ts).
     // Sequential fallback on any pool failure. CODEGRAPH_NO_PARALLEL_RESOLVE=1
-    // disables entirely.
-    parallel?: { dbPath: string }
+    // disables entirely. bulkEdgeLoad hooks (when provided) bracket the batch
+    // loop with drop/recreate of the non-unique edge indexes on big runs —
+    // see DatabaseConnection.beginBulkEdgeLoad.
+    parallel?: { dbPath: string; bulkEdgeLoad?: { begin: () => void; end: () => void } }
   ): Promise<ResolutionResult> {
     // Resolution runs on the indexer's MAIN thread, and the #850 liveness
     // watchdog SIGKILLs a process whose event loop stalls past its window (60s
@@ -1444,6 +1446,22 @@ export class ReferenceResolver {
       return this.resolveBatchYielding(batch, maybeYield);
     };
 
+    // Bulk edge load: on big runs, drop the non-unique edge indexes for the
+    // duration of the batch loop (the identity index stays — OR IGNORE dedup
+    // and the source-keyed supertype-walk reads both live on it). Recreated in
+    // the inner finally BEFORE synthesis, whose passes read kind-keyed.
+    // Measured on a 224k-edge resolution set: insert 2.8s → 1.1s + 0.3s
+    // recreate. Same ref-count gate as the pool so small syncs never pay the
+    // recreate cost.
+    let bulkEdgesActive = false;
+    if (parallel?.bulkEdgeLoad && total >= minRefsForPool()) {
+      try {
+        parallel.bulkEdgeLoad.begin();
+        bulkEdgesActive = true;
+      } catch { /* keep the indexes; inserts just pay the per-row maintenance */ }
+    }
+
+    try {
     try {
     let batch = this.queries.getUnresolvedReferencesBatch(0, batchSize);
     let inFlight: InFlight | null = batch.length > 0 ? beginBatch(batch) : null;
@@ -1559,6 +1577,16 @@ export class ReferenceResolver {
       batch = nextBatch;
       inFlight = nextInFlight;
     }
+    } finally {
+      // Recreate the edge indexes BEFORE synthesis (kind-keyed reads) and on
+      // any error path. A crash before this line is healed by the next
+      // DatabaseConnection open (schema.sql re-applies IF NOT EXISTS).
+      if (bulkEdgesActive) {
+        const tIdx = Date.now();
+        parallel!.bulkEdgeLoad!.end();
+        if (process.env.CODEGRAPH_SYNTH_TIMINGS) console.error(`[phase-timing] edge-index-recreate: ${Date.now() - tIdx}ms`);
+      }
+    }
 
     // Dynamic-edge synthesis: now that all base `calls` edges are persisted,
     // synthesize observer/callback dispatch edges (dispatcher → registered