gitnexus 1.6.13-rc.71 → 1.6.13-rc.73

package/dist/cli/embeddings-sync.js

@@ -4,7 +4,7 @@ import { LBUG_DIRECTORY } from '../storage/storage-constants.js';
 import path from 'node:path';
 import { cliInfo } from './cli-message.js';
 import { getGitRoot } from '../storage/git.js';
-import { acquireIndexLock, requireExclusiveIndexLock } from '../storage/index-lock.js';
+import { acquireIndexLock, requireExclusiveIndexLock, sweepStagingArtifacts, } from '../storage/index-lock.js';
 import { getStoragePaths, loadMeta, saveMeta } from '../storage/repo-manager.js';
 import { closeLbug, executeQuery, executeWithReusedStatement, fetchExistingEmbeddingHashes, initLbug, } from '../core/lbug/lbug-adapter.js';
 import { decideEmbeddingResume, mintInterruptedCheckpoint, mintPartialCheckpoint, mintUnverifiedCountCheckpoint, } from '../core/embedding-checkpoint.js';
@@ -24,9 +24,17 @@ export const embeddingsSyncCommand = async (inputPath) => {
     // Writes go to the slot's own graph. A shared-store checkout that reads an
     // immutable commit graph (#3352) takes a private copy first.
     const lbugPath = path.join(metaDir, LBUG_DIRECTORY);
-    const lock = await acquireIndexLock(metaDir);
+    const lock = await acquireIndexLock(metaDir, { sweep: false });
     try {
         requireExclusiveIndexLock(lock, `Cannot acquire the index lock at ${metaDir}; refusing an unlocked embeddings sync.`);
+        // Sync writes the published graph and cannot recover a staged generation.
+        // Reject even malformed receipts before sweeping staging files or writing.
+        const recoveryCheckpoint = (await loadMeta(metaDir))?.embeddingCheckpoint;
+        if (recoveryCheckpoint && Object.hasOwn(recoveryCheckpoint, 'recovery')) {
+            throw new Error('Cannot sync embeddings: the index checkpoint references staged embeddings. ' +
+                'Run `gitnexus analyze` to recover them first.');
+        }
+        sweepStagingArtifacts(metaDir);
         if (!(await ensurePrivateSharedGraph(metaDir, (m) => console.log(`  ${m}`)))) {
             throw new Error('The shared graph this checkout reads is gone. Run gitnexus analyze first.');
         }

package/dist/core/embeddings/staged-embedding-recovery-child.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/embeddings/staged-embedding-recovery-child.js

@@ -0,0 +1,170 @@
+/** Isolated strict native reader. Never import this entrypoint into analyze. */
+import fs from 'node:fs';
+import path from 'node:path';
+import lbug from '@ladybugdb/core';
+import { createLbugDatabase, toNativeSafePath } from '../lbug/lbug-config.js';
+import { FAMILY_SUFFIXES } from '../../storage/embedding-recovery.js';
+import { abortCachedEmbeddingsBuilder, createCachedEmbeddingsBuilder, finalizeCachedEmbeddingsSnapshot, ingestCachedEmbeddingRow, } from './embedding-restore-spill.js';
+/** Native replay and close may checkpoint; only give them disposable copies. */
+function copyRecoveryFamily(dbPath, exportDir) {
+    const replayDir = fs.mkdtempSync(path.join(exportDir, 'replay-'));
+    const replayPath = path.join(replayDir, path.basename(dbPath));
+    const noFollow = fs.constants.O_NOFOLLOW ?? 0;
+    const flags = fs.constants.O_RDONLY | noFollow | (fs.constants.O_NONBLOCK ?? 0);
+    const buffer = Buffer.allocUnsafe(1024 * 1024);
+    for (const suffix of FAMILY_SUFFIXES) {
+        const sourcePath = dbPath + suffix;
+        let entry;
+        try {
+            entry = fs.lstatSync(sourcePath, { bigint: true });
+        }
+        catch (error) {
+            if (suffix && error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        if (!entry.isFile())
+            throw new Error('staged embedding family is not a regular file');
+        const source = fs.openSync(sourcePath, flags);
+        let destination;
+        try {
+            const opened = fs.fstatSync(source, { bigint: true });
+            const current = fs.lstatSync(sourcePath, { bigint: true });
+            if (!opened.isFile() ||
+                !current.isFile() ||
+                (noFollow === 0 && opened.ino === 0n) ||
+                opened.dev !== entry.dev ||
+                opened.ino !== entry.ino ||
+                opened.dev !== current.dev ||
+                opened.ino !== current.ino) {
+                throw new Error('staged embedding family changed while opening');
+            }
+            destination = fs.openSync(replayPath + suffix, 'wx', 0o600);
+            let copied = 0n;
+            for (;;) {
+                const bytesRead = fs.readSync(source, buffer, 0, buffer.length, null);
+                if (bytesRead === 0)
+                    break;
+                fs.writeFileSync(destination, buffer.subarray(0, bytesRead));
+                copied += BigInt(bytesRead);
+            }
+            const after = fs.fstatSync(source, { bigint: true });
+            if (copied !== opened.size ||
+                after.size !== opened.size ||
+                after.mtimeNs !== opened.mtimeNs ||
+                after.ctimeNs !== opened.ctimeNs) {
+                throw new Error('staged embedding family changed while copying');
+            }
+        }
+        finally {
+            try {
+                if (destination !== undefined)
+                    fs.closeSync(destination);
+            }
+            finally {
+                fs.closeSync(source);
+            }
+        }
+    }
+    return replayPath;
+}
+async function extract() {
+    const [dbPath, exportDir, dimensionsArg] = process.argv.slice(2);
+    const dimensions = Number(dimensionsArg);
+    if (!dbPath || !exportDir || !Number.isInteger(dimensions) || dimensions <= 0) {
+        throw new Error('invalid staged embedding extraction arguments');
+    }
+    // The parent owns exportDir and reclaims it even after killing this child.
+    const replayPath = copyRecoveryFamily(dbPath, exportDir);
+    const builder = createCachedEmbeddingsBuilder({ inMemoryRowLimit: 0, spillDir: exportDir });
+    const rejectedNodeIds = new Set();
+    let db;
+    let conn;
+    try {
+        // Avoid openLbugConnection's test-fixture lock sweep: a recovery source must
+        // never have its WAL removed, even when an external slot resembles a fixture.
+        db = createLbugDatabase(lbug, toNativeSafePath(replayPath), { throwOnWalReplayFailure: true });
+        conn = new lbug.Connection(db);
+        const queried = await conn.query('MATCH (e:CodeEmbedding) RETURN e.nodeId AS nodeId, e.chunkIndex AS chunkIndex, e.startLine AS startLine, e.endLine AS endLine, e.embedding AS embedding, e.contentHash AS contentHash');
+        const results = Array.isArray(queried) ? queried : [queried];
+        try {
+            if (results.length !== 1)
+                throw new Error('unexpected staged embedding query result');
+            const result = results[0];
+            while (await result.hasNext()) {
+                const raw = await result.getNext();
+                const rec = raw;
+                const nodeId = rec.nodeId ?? rec[0];
+                if (typeof nodeId !== 'string' || !nodeId)
+                    throw new Error('invalid staged embedding node id');
+                const chunkIndex = rec.chunkIndex ?? rec[1];
+                const startLine = rec.startLine ?? rec[2];
+                const endLine = rec.endLine ?? rec[3];
+                const embedding = rec.embedding ?? rec[4];
+                const contentHash = rec.contentHash ?? rec[5];
+                const vector = Array.isArray(embedding) ||
+                    (ArrayBuffer.isView(embedding) && !(embedding instanceof DataView))
+                    ? Array.from(embedding)
+                    : undefined;
+                if (!Number.isInteger(chunkIndex) ||
+                    Number(chunkIndex) < 0 ||
+                    !Number.isInteger(startLine) ||
+                    Number(startLine) < 0 ||
+                    !Number.isInteger(endLine) ||
+                    Number(endLine) < Number(startLine) ||
+                    typeof contentHash !== 'string' ||
+                    !contentHash ||
+                    !vector ||
+                    vector.length !== dimensions ||
+                    vector.some((value) => typeof value !== 'number' ||
+                        !Number.isFinite(value) ||
+                        !Number.isFinite(Math.fround(value)))) {
+                    rejectedNodeIds.add(nodeId);
+                    continue;
+                }
+                ingestCachedEmbeddingRow(builder, { nodeId, chunkIndex, startLine, endLine, embedding: vector, contentHash }, true);
+            }
+        }
+        finally {
+            for (const result of results)
+                await result.close();
+        }
+        // Both closes must succeed. Suppressed native teardown errors are unsafe.
+        await conn.close();
+        await db.close();
+        const snapshot = finalizeCachedEmbeddingsSnapshot(builder);
+        if (snapshot.spill)
+            fs.renameSync(snapshot.spill.path, path.join(exportDir, 'vectors.bin'));
+        const manifest = {
+            version: 1,
+            dimensions,
+            rows: snapshot.rows,
+            rejectedNodeIds: [...rejectedNodeIds],
+        };
+        fs.writeFileSync(path.join(exportDir, 'manifest.json'), JSON.stringify(manifest), {
+            flag: 'wx',
+            mode: 0o600,
+        });
+    }
+    catch (err) {
+        abortCachedEmbeddingsBuilder(builder);
+        // Cleanup is best effort on a rejected source, never used to approve output.
+        try {
+            await conn?.close();
+        }
+        catch {
+            /* rejected */
+        }
+        try {
+            await db?.close();
+        }
+        catch {
+            /* rejected */
+        }
+        throw err;
+    }
+}
+extract().catch((err) => {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    process.exitCode = 1;
+});

package/dist/core/embeddings/staged-embedding-recovery.d.ts

@@ -0,0 +1,23 @@
+import { type CachedEmbeddingMeta, type CachedEmbeddingsSnapshot } from './embedding-restore-spill.js';
+export interface StagedEmbeddingRecoveryOptions {
+    dimensions: number;
+    /** Active checkpoint window and any incomplete inherited restore groups. */
+    excludedNodeIds?: Iterable<string>;
+    timeoutMs?: number;
+}
+export interface StagedEmbeddingExport {
+    version: 1;
+    dimensions: number;
+    rows: CachedEmbeddingMeta[];
+    rejectedNodeIds: string[];
+}
+/** A contiguous prefix is safe only when its node is outside every unsafe window. */
+export declare function validateRecoveredNodeGroups(rows: readonly CachedEmbeddingMeta[], excludedNodeIds?: ReadonlySet<string>): Set<string>;
+/** Whole recovered nodes replace whole published groups; vectors stay in bounded batches. */
+export declare function mergeRecoveredEmbeddings(live: CachedEmbeddingsSnapshot, recovered: CachedEmbeddingsSnapshot): CachedEmbeddingsSnapshot;
+/**
+ * Caller must validate checkpoint identity, schema, exact generation, and hold the
+ * index lock. A subprocess contains native WAL replay/query/destructor failures.
+ * A failed strict open is never retried with WAL removed or validation disabled.
+ */
+export declare function recoverStagedEmbeddings(dbPath: string, options: StagedEmbeddingRecoveryOptions): Promise<CachedEmbeddingsSnapshot>;

package/dist/core/embeddings/staged-embedding-recovery.js

@@ -0,0 +1,183 @@
+/** Recover paid embedding rows without opening an interrupted native DB in analyze. */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { abortCachedEmbeddingsBuilder, createCachedEmbeddingsBuilder, EmbeddingSpillReader, emptyCachedEmbeddingsSnapshot, finalizeCachedEmbeddingsSnapshot, ingestCachedEmbeddingRow, materializeCachedEmbeddings, } from './embedding-restore-spill.js';
+const RESTORE_BATCH_SIZE = 200;
+const DEFAULT_EXTRACTION_TIMEOUT_MS = 120_000;
+/** A contiguous prefix is safe only when its node is outside every unsafe window. */
+export function validateRecoveredNodeGroups(rows, excludedNodeIds = new Set()) {
+    const groups = new Map();
+    for (const row of rows) {
+        let group = groups.get(row.nodeId);
+        if (!group) {
+            group = { hash: row.contentHash, ordinals: new Set(), invalid: false };
+            groups.set(row.nodeId, group);
+        }
+        if (typeof row.nodeId !== 'string' ||
+            !row.nodeId ||
+            typeof row.contentHash !== 'string' ||
+            !row.contentHash ||
+            row.contentHash !== group.hash ||
+            !Number.isInteger(row.chunkIndex) ||
+            row.chunkIndex < 0 ||
+            group.ordinals.has(row.chunkIndex) ||
+            !Number.isInteger(row.startLine) ||
+            row.startLine < 0 ||
+            !Number.isInteger(row.endLine) ||
+            row.endLine < row.startLine)
+            group.invalid = true;
+        group.ordinals.add(row.chunkIndex);
+    }
+    const accepted = new Set();
+    for (const [nodeId, group] of groups) {
+        if (group.invalid || excludedNodeIds.has(nodeId))
+            continue;
+        // Unique ordinals with max n-1 and zero present have no holes.
+        if (!group.ordinals.has(0))
+            continue;
+        if ([...group.ordinals].some((ordinal) => ordinal >= group.ordinals.size))
+            continue;
+        accepted.add(nodeId);
+    }
+    return accepted;
+}
+/** Whole recovered nodes replace whole published groups; vectors stay in bounded batches. */
+export function mergeRecoveredEmbeddings(live, recovered) {
+    const builder = createCachedEmbeddingsBuilder({ inMemoryRowLimit: 0 });
+    try {
+        appendSnapshotRows(live, live.rows.filter((row) => !recovered.embeddingNodeIds.has(row.nodeId)), builder);
+        appendSnapshotRows(recovered, recovered.rows, builder);
+        return finalizeCachedEmbeddingsSnapshot(builder);
+    }
+    catch (err) {
+        abortCachedEmbeddingsBuilder(builder);
+        throw err;
+    }
+}
+function appendSnapshotRows(snapshot, rows, builder) {
+    const reader = snapshot.spill ? new EmbeddingSpillReader(snapshot.spill) : undefined;
+    try {
+        for (let i = 0; i < rows.length; i += RESTORE_BATCH_SIZE) {
+            const batch = materializeCachedEmbeddings(snapshot, rows.slice(i, i + RESTORE_BATCH_SIZE), reader);
+            for (const row of batch)
+                ingestCachedEmbeddingRow(builder, row, true);
+        }
+    }
+    finally {
+        reader?.close();
+    }
+}
+/**
+ * Caller must validate checkpoint identity, schema, exact generation, and hold the
+ * index lock. A subprocess contains native WAL replay/query/destructor failures.
+ * A failed strict open is never retried with WAL removed or validation disabled.
+ */
+export async function recoverStagedEmbeddings(dbPath, options) {
+    if (!Number.isInteger(options.dimensions) || options.dimensions <= 0) {
+        throw new Error('invalid staged embedding dimensions');
+    }
+    const dbStat = fs.lstatSync(dbPath);
+    if (!dbStat.isFile() || dbStat.isSymbolicLink())
+        throw new Error('staged embedding DB is not a regular file');
+    const exportDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gitnexus-stage-export-'));
+    try {
+        await runExtractionChild(dbPath, exportDir, options);
+        const manifestPath = path.join(exportDir, 'manifest.json');
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        if (manifest.version !== 1 ||
+            manifest.dimensions !== options.dimensions ||
+            !Array.isArray(manifest.rows) ||
+            !Array.isArray(manifest.rejectedNodeIds) ||
+            manifest.rejectedNodeIds.some((id) => typeof id !== 'string') ||
+            manifest.rows.some((row, i) => !row || row.vectorIndex !== i))
+            throw new Error('invalid staged embedding export manifest');
+        if (manifest.rows.length === 0)
+            return emptyCachedEmbeddingsSnapshot();
+        const spill = {
+            path: path.join(exportDir, 'vectors.bin'),
+            dims: options.dimensions,
+            rowCount: manifest.rows.length,
+        };
+        const vectorStat = fs.lstatSync(spill.path);
+        if (!vectorStat.isFile() ||
+            vectorStat.isSymbolicLink() ||
+            vectorStat.size !== 12 + spill.rowCount * spill.dims * 4) {
+            throw new Error('invalid staged embedding export size');
+        }
+        const excluded = new Set(options.excludedNodeIds ?? []);
+        for (const nodeId of manifest.rejectedNodeIds)
+            excluded.add(nodeId);
+        const accepted = validateRecoveredNodeGroups(manifest.rows, excluded);
+        const exported = {
+            rows: manifest.rows,
+            embeddings: [],
+            embeddingNodeIds: accepted,
+            spill,
+        };
+        const builder = createCachedEmbeddingsBuilder({ inMemoryRowLimit: 0 });
+        const reader = new EmbeddingSpillReader(spill);
+        try {
+            const rows = manifest.rows.filter((row) => accepted.has(row.nodeId));
+            for (let i = 0; i < rows.length; i += RESTORE_BATCH_SIZE) {
+                for (const row of materializeCachedEmbeddings(exported, rows.slice(i, i + RESTORE_BATCH_SIZE), reader)) {
+                    if (row.embedding.length !== options.dimensions ||
+                        row.embedding.some((value) => !Number.isFinite(value))) {
+                        throw new Error('invalid staged embedding vector');
+                    }
+                    ingestCachedEmbeddingRow(builder, row, true);
+                }
+            }
+            return finalizeCachedEmbeddingsSnapshot(builder);
+        }
+        catch (err) {
+            abortCachedEmbeddingsBuilder(builder);
+            throw err;
+        }
+        finally {
+            reader.close();
+        }
+    }
+    finally {
+        fs.rmSync(exportDir, { recursive: true, force: true });
+    }
+}
+function runExtractionChild(dbPath, exportDir, options) {
+    const compiledPath = fileURLToPath(new URL('./staged-embedding-recovery-child.js', import.meta.url));
+    const sourcePath = compiledPath.replace(/\.js$/, '.ts');
+    const childPath = fs.existsSync(compiledPath) ? compiledPath : sourcePath;
+    const args = childPath.endsWith('.ts')
+        ? ['--import', import.meta.resolve('tsx'), childPath]
+        : [childPath];
+    args.push(dbPath, exportDir, String(options.dimensions));
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, args, {
+            stdio: ['ignore', 'ignore', 'pipe'],
+            windowsHide: true,
+        });
+        let stderr = '';
+        let timedOut = false;
+        child.stderr.on('data', (chunk) => {
+            if (stderr.length < 4096)
+                stderr += chunk.toString().slice(0, 4096 - stderr.length);
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            // A process boundary is safe to kill even while native code is executing.
+            child.kill('SIGKILL');
+        }, options.timeoutMs ?? DEFAULT_EXTRACTION_TIMEOUT_MS);
+        child.once('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.once('close', (code, signal) => {
+            clearTimeout(timer);
+            if (code === 0 && !signal && !timedOut)
+                resolve();
+            else
+                reject(new Error(`staged embedding extraction failed${timedOut ? ' (timeout)' : ` (${signal ?? code})`}${stderr ? `: ${stderr.trim()}` : ''}`));
+        });
+    });
+}

package/dist/core/run-analyze.js

@@ -17,7 +17,8 @@ import fs from 'fs/promises';
 import { constants as fsConstants, existsSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { retryRename } from '../storage/fs-atomic.js';
-import { acquireIndexLock, requireExclusiveIndexLock } from '../storage/index-lock.js';
+import { acquireIndexLock, requireExclusiveIndexLock, sweepStagingArtifacts, } from '../storage/index-lock.js';
+import { resolveEmbeddingRecovery } from '../storage/embedding-recovery.js';
 import { invalidateNodeWorkspacePackages } from './ingestion/import-resolvers/node-workspace-packages.js';
 import { logNameFallbackSummary, summarizeNameFallback, countCallsByLanguage, } from './ingestion/scope-resolution/name-fallback-summary.js';
 import { runPipelineFromRepo } from './ingestion/pipeline.js';
@@ -657,6 +658,8 @@ export async function runFullAnalysis(repoPath, options, callbacks, runnerIdenti
     const log = (msg) => callbacks.onLog?.(stripControlCharacters(msg));
     const acquireOpts = {
         log,
+        // Resolve and validate the canonical slot under the lock before cleanup.
+        sweep: false,
         onWaitStart: () => callbacks.onProgress('lock', 0, 'Waiting for another analyze to finish on this index…'),
     };
     let writeTarget = await resolveWriteTarget(repoPath, options);
@@ -702,6 +705,7 @@ export async function runFullAnalysis(repoPath, options, callbacks, runnerIdenti
             const flatShared = writeTarget.placement.branch ? undefined : writeTarget.sharedStore;
             if (flatShared)
                 await seedSharedSlot(flatShared, repoPath, log);
+            sweepStagingArtifacts(writeTarget.metaDir, log);
             const slotToLeave = options.noShare ? await optedInSlotToLeave(repoPath) : undefined;
             const result = await runFullAnalysisInner(repoPath, options, callbacks, writeTarget, contentRetention, runnerIdentityAtBootstrap);
             if (flatShared) {
@@ -1144,7 +1148,11 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
         }
         if (decision.action === 'abort')
             throw new Error(decision.error);
-        log(decision.log);
+        log(decision.action === 'resume' && checkpoint.recovery
+            ? `Previous analyze recorded an embedding checkpoint (${checkpoint.nodesProcessed}/` +
+                `${checkpoint.totalNodes} nodes); validating staged vectors before retrying ` +
+                `${decision.pendingNodeIds.size} pending node(s).`
+            : decision.log);
         if (options.dropEmbeddings) {
             // --drop-embeddings has always implied a rebuild here; the decision only
             // covers the marker.
@@ -1877,6 +1885,68 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
             }
         }
     }
+    // A checkpoint's pending decision and its paid, complete vectors are
+    // independent: --force discards the former but can still reuse the latter.
+    // Select only the explicitly referenced generation, never an orphan by age.
+    const stagedRecovery = resolveEmbeddingRecovery(metaDir, existingMeta?.embeddingCheckpoint);
+    const stagedCheckpoint = existingMeta?.embeddingCheckpoint;
+    const inheritedUnsafeNodeIds = new Set([
+        ...pendingEmbeddingNodeIds,
+        ...(stagedRecovery?.unsafeNodeIds ?? []),
+    ]);
+    if (shouldLoadCache && !options.dropEmbeddings && stagedRecovery && stagedCheckpoint) {
+        if (!embeddingIdentityForRun) {
+            const { resolveEmbeddingIdentity } = await import('./embeddings/embedding-identity.js');
+            embeddingIdentityForRun = resolveEmbeddingIdentity();
+        }
+        const marker = stagedCheckpoint;
+        const matchesIdentity = marker.model === embeddingIdentityForRun.model &&
+            marker.dimensions === embeddingIdentityForRun.dimensions &&
+            marker.provider === embeddingIdentityForRun.provider;
+        if (matchesIdentity && stagedRecovery.schemaFingerprint === SCHEMA_FINGERPRINT) {
+            // A force-discarded pending decision must not turn a known incomplete
+            // inherited group into a reusable cache merely because its hash matches.
+            if (inheritedUnsafeNodeIds.size > 0) {
+                const rows = cachedSnapshot.rows.filter((row) => !inheritedUnsafeNodeIds.has(row.nodeId));
+                cachedSnapshot = {
+                    ...cachedSnapshot,
+                    rows,
+                    embeddingNodeIds: new Set(rows.map((row) => row.nodeId)),
+                };
+            }
+            let recovered;
+            try {
+                const { recoverStagedEmbeddings, mergeRecoveredEmbeddings } = await import('./embeddings/staged-embedding-recovery.js');
+                recovered = await recoverStagedEmbeddings(stagedRecovery.dbPath, {
+                    dimensions: embeddingIdentityForRun.dimensions,
+                    excludedNodeIds: stagedRecovery.unsafeNodeIds,
+                });
+                const liveCacheDims = snapshotEmbeddingDims(cachedSnapshot);
+                if (liveCacheDims !== undefined && liveCacheDims !== embeddingIdentityForRun.dimensions) {
+                    log(`Embedding dimensions changed (${liveCacheDims}d -> ` +
+                        `${embeddingIdentityForRun.dimensions}d), discarding published cache`);
+                    discardCachedEmbeddings();
+                }
+                if (recovered.rows.length > 0) {
+                    const merged = mergeRecoveredEmbeddings(cachedSnapshot, recovered);
+                    disposeEmbeddingSpill(cachedSnapshot.spill);
+                    adoptCachedEmbeddings(merged);
+                }
+                log(`Recovered ${recovered.rows.length} complete staged embedding chunk(s) ` +
+                    `for ${recovered.embeddingNodeIds.size} node(s); unchanged content can reuse them.`);
+            }
+            catch (err) {
+                log(`Warning: could not recover staged embeddings (${err.message}); ` +
+                    'the retry will regenerate missing chunks.');
+            }
+            finally {
+                disposeEmbeddingSpill(recovered?.spill);
+            }
+        }
+        else {
+            log('Staged embedding identity or schema changed; its vectors will not be reused.');
+        }
+    }
     // ── Load incremental parse cache ──────────────────────────────────
     // Content-addressed: `--force` reuses parser shards; `useParseCache: false`
     // stages a new generation under a run-unique parse-rebuild.* dir and publishes
@@ -3505,6 +3575,7 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
             const vectorIndexReady = await buildVectorIndex();
             semanticMode = vectorIndexReady ? 'vector-index' : 'exact-scan';
         }
+        let stagedCheckpointEmbeddingCount;
         if (!embeddingSkipped) {
             const { isHttpMode } = await import('./embeddings/http-client.js');
             const httpMode = isHttpMode();
@@ -3515,6 +3586,14 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
                 embeddingIdentityForRun = resolveEmbeddingIdentity();
             }
             const embeddingIdentity = embeddingIdentityForRun;
+            const stagedRecoveryEnabled = useAtomicSwap && isManualCheckpointEnabled();
+            if (useAtomicSwap && !stagedRecoveryEnabled) {
+                log('Manual WAL checkpoints are disabled; new staged work cannot be recovered after interruption. ' +
+                    'Any previous durable recovery source is retained until publication.');
+            }
+            const unsafeRecoveryNodeIds = new Set([...inheritedUnsafeNodeIds, ...restoreFailedNodeIds]);
+            let activeWindowNodeIds = [];
+            let recoveryGenerationDurable = false;
             // Build a Map<nodeId, contentHash> from cached embeddings for incremental mode
             let existingEmbeddings;
             if (cachedSnapshot.embeddingNodeIds.size > 0) {
@@ -3550,13 +3629,22 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
             // /api/embed checkpoint writer in server/api.ts already uses, which also
             // keeps a concurrent writer's update from being reverted by a stale
             // snapshot) and replace ONLY `embeddingCheckpoint` — plus
-            // `stats.embeddings` when the caller actually MEASURED the live count
-            // (the post-window `onCheckpoint`). The window-start callback passes
-            // nothing: restating the previous run's count there both re-published a
-            // stale number and clobbered the live count a preceding `onCheckpoint`
-            // had just written.
+            // `stats.embeddings` when the caller actually MEASURED the published
+            // index (the post-window `onCheckpoint` on an in-place build). A staging
+            // build's count is not published until the atomic swap succeeds. The
+            // window-start callback passes nothing, preserving the latest count.
             const saveEmbeddingCheckpoint = async (checkpoint, pendingNodeIds, embeddings) => {
+                if (embeddings !== undefined && buildPath !== lbugPath) {
+                    stagedCheckpointEmbeddingCount = embeddings;
+                }
                 const latestMeta = (await loadMeta(metaDir)) ?? existingMeta;
+                // An in-place write or manual-checkpoint opt-out cannot create a new
+                // recoverable staged generation. Keep the complete previous receipt:
+                // updated progress or unsafe nodes would describe different source bytes.
+                const preservedRecoveryCheckpoint = !stagedRecoveryEnabled &&
+                    resolveEmbeddingRecovery(metaDir, latestMeta?.embeddingCheckpoint)
+                    ? latestMeta?.embeddingCheckpoint
+                    : undefined;
                 // First-ever analyze of this repo: no meta exists on disk yet (the
                 // pre-wipe dirty stamp only fires when one does). Mint the minimum
                 // RepoMeta requires, with `lastCommit: ''` — never `currentCommit` —
@@ -3567,12 +3655,26 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
                     lastCommit: '',
                     indexedAt: new Date().toISOString(),
                 };
+                const interrupted = mintInterruptedCheckpoint(embeddingIdentity, checkpoint, pendingNodeIds);
                 await saveMeta(metaDir, {
                     ...base,
-                    ...(embeddings === undefined ? {} : { stats: { ...base.stats, embeddings } }),
+                    ...(embeddings === undefined || buildPath !== lbugPath
+                        ? {}
+                        : { stats: { ...base.stats, embeddings } }),
                     // Written by a run that is still IN FLIGHT — see the `kind` doc in
                     // repo-manager.ts.
-                    embeddingCheckpoint: mintInterruptedCheckpoint(embeddingIdentity, checkpoint, pendingNodeIds),
+                    embeddingCheckpoint: preservedRecoveryCheckpoint ?? {
+                        ...interrupted,
+                        ...(stagedRecoveryEnabled
+                            ? {
+                                recovery: {
+                                    stagingFile: path.basename(buildPath),
+                                    schemaFingerprint: SCHEMA_FINGERPRINT,
+                                    unsafeNodeIds: [...unsafeRecoveryNodeIds],
+                                },
+                            }
+                            : {}),
+                    },
                 });
             };
             embeddingResult = await runEmbeddingPipeline(executeQuery, executeWithReusedStatement, (p) => {
@@ -3586,7 +3688,21 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
             }, {}, cachedSnapshot.embeddingNodeIds.size > 0 ? cachedSnapshot.embeddingNodeIds : undefined, existingEmbeddings, {
                 forceReembedNodeIds: pendingEmbeddingNodeIds,
                 onCheckpointWindowStart: async ({ nodeIds, ...checkpoint }) => {
+                    const handoff = stagedRecoveryEnabled && !recoveryGenerationDurable;
+                    if (handoff) {
+                        if (!(await checkpointOnce())) {
+                            throw new Error('Could not checkpoint restored embeddings before recovery handoff.');
+                        }
+                        recoveryGenerationDurable = true;
+                    }
+                    activeWindowNodeIds = nodeIds;
+                    for (const id of nodeIds)
+                        unsafeRecoveryNodeIds.add(id);
                     await saveEmbeddingCheckpoint(checkpoint, nodeIds);
+                    // Reclaim the old source only after the new durable generation's
+                    // reference is saved. Later windows retain this same generation.
+                    if (handoff)
+                        sweepStagingArtifacts(metaDir, log);
                 },
                 // ── The mid-run count is a DIAGNOSTIC, not a gate (#2790) ──────
                 // This used to run the count query bare. THIS callback's rejection
@@ -3600,7 +3716,13 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
                 // touch stats.embeddings" signal — so the checkpoint still lands,
                 // with whatever count is already on disk left alone.
                 onCheckpoint: async (checkpoint) => {
-                    await checkpointOnce();
+                    const durable = await checkpointOnce();
+                    if (stagedRecoveryEnabled && !durable) {
+                        throw new Error('Could not checkpoint the completed embedding window for recovery.');
+                    }
+                    for (const id of activeWindowNodeIds)
+                        unsafeRecoveryNodeIds.delete(id);
+                    activeWindowNodeIds = [];
                     const measured = await measurePersistedEmbeddingCount(executeQuery);
                     if (measured.kind === 'unknown') {
                         log(`Warning: could not measure persisted embeddings at the embedding checkpoint ` +
@@ -3726,11 +3848,10 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
         // already written to disk: prior meta says 0, a clean run inserts
         // embeddings and checkpoints the real count, the final probe is
         // unavailable, and finalization carries the stale 0 forward while reporting
-        // success. `loadMeta` never throws (it returns null), and the checkpoint
-        // writer already re-reads the same way, so this is the same freshness
-        // discipline applied to the same field.
+        // success. For a staged build, use its last measured count only in the
+        // final meta, written after the swap; never publish it at a checkpoint.
         const latestMetaForCount = embeddingCount === undefined ? ((await loadMeta(metaDir)) ?? existingMeta) : undefined;
-        const persistedEmbeddingCount = resolvePersistedEmbeddingCount(measuredEmbeddingCount, latestMetaForCount?.stats?.embeddings);
+        const persistedEmbeddingCount = resolvePersistedEmbeddingCount(measuredEmbeddingCount, stagedCheckpointEmbeddingCount ?? latestMetaForCount?.stats?.embeddings);
         const { getRuntimeCapabilities } = await import('./platform/capabilities.js');
         const runtimeCapabilities = getRuntimeCapabilities();
         // `semanticMode` is authoritative when set (Phase 4 reported what it
@@ -4018,6 +4139,7 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
         // is a crash-safety improvement: a failed swap leaves the previous index
         // live and the next run recovers via the full-rebuild path.
         await saveMeta(metaDir, meta);
+        sweepStagingArtifacts(metaDir, log);
         // Registry freshness is published only after the graph and its metadata.
         // A failed close, swap, or metadata save must leave the previous registry
         // receipt intact, just as it leaves the cache unpublished.
@@ -4213,7 +4335,11 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
         // rethrow below is the surface, and the lock's sweep remains the backstop.
         if (useAtomicSwap && buildPath !== lbugPath) {
             try {
-                await wipeLbugDbFiles(buildPath);
+                const recovery = resolveEmbeddingRecovery(metaDir, (await loadMeta(metaDir))?.embeddingCheckpoint);
+                // Both paths belong to this locked slot. The validated generation
+                // basename identifies the same file even through a directory alias.
+                if (recovery?.stagingFile !== path.basename(buildPath))
+                    await wipeLbugDbFiles(buildPath);
             }
             catch {
                 /* swallow — orphan reclamation must never mask the real failure */
@@ -4226,6 +4352,10 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
             // IndexLockTimeoutError and other domain failures with `instanceof`.
             recordLiveIndexMutationRisk(err);
         }
+        if (/max(?:imum)?(?: database| db)? size|database size limit|maxDBSize/i.test(String(err))) {
+            log('The database size limit was reached. Set GITNEXUS_LBUG_MAX_DB_SIZE to a larger ' +
+                'byte limit before retrying analyze; retained complete embeddings can be reused.');
+        }
         throw err;
     }
 }

package/dist/server/api.js

@@ -7,7 +7,7 @@
  * Security: binds to localhost by default (use --host to override).
  * CORS is restricted to localhost, private/LAN networks, and the deployed site.
  */
-import { acquireIndexLock, IndexLockTimeoutError, requireExclusiveIndexLock, } from '../storage/index-lock.js';
+import { acquireIndexLock, IndexLockTimeoutError, requireExclusiveIndexLock, sweepStagingArtifacts, } from '../storage/index-lock.js';
 import { ensurePrivateSharedGraph } from '../core/shared-store-analyze.js';
 import { resolveGraphPath } from '../storage/shared-store.js';
 import { reclaimAfterSlotRemoval, removeCheckoutStorage, } from '../storage/shared-store-lifecycle.js';
@@ -1797,8 +1797,16 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 // for the whole embedding write, released in the finally below.
                 let slotLock;
                 try {
-                    slotLock = await acquireIndexLock(storagePath);
+                    slotLock = await acquireIndexLock(storagePath, { sweep: false });
                     requireExclusiveIndexLock(slotLock, `Cannot acquire the index lock at ${storagePath}; refusing an unlocked embedding run.`);
+                    // This writer cannot recover staged generations. Preserve their
+                    // receipts, including malformed ones, before sweeping or writing.
+                    const recoveryCheckpoint = (await loadMeta(storagePath))?.embeddingCheckpoint;
+                    if (recoveryCheckpoint && Object.hasOwn(recoveryCheckpoint, 'recovery')) {
+                        throw new Error('Cannot generate embeddings: the index checkpoint references staged embeddings. ' +
+                            'Run `gitnexus analyze` to recover them first.');
+                    }
+                    sweepStagingArtifacts(storagePath);
                     // Writes go to the slot's own graph; a shared-store checkout
                     // reading an immutable commit graph (#3352) takes a private copy.
                     if (!(await ensurePrivateSharedGraph(storagePath, () => { }))) {

package/dist/storage/embedding-recovery.d.ts

@@ -0,0 +1,15 @@
+import type { EmbeddingRecoveryReference } from './repo-meta.js';
+export declare const FAMILY_SUFFIXES: readonly ['', '.wal', '.shadow', '.wal.checkpoint', '.lock', '.checkpoint.intent.lock', '.checkpoint.apply.lock'];
+export interface ResolvedEmbeddingRecovery extends EmbeddingRecoveryReference {
+    dbPath: string;
+    /** Exact basenames, never a prefix match that can preserve another generation. */
+    familyFiles: string[];
+}
+/**
+ * Resolve only an explicit interrupted-generation receipt in this canonical
+ * slot. This validates provenance, not native contents or current identity;
+ * those checks must pass separately before any rows can be reused.
+ */
+export declare const resolveEmbeddingRecovery: (lockDir: string, checkpoint: unknown) => ResolvedEmbeddingRecovery | undefined;
+/** Synchronous mirror of loadMeta's primary-first, absent-only fallback rule. */
+export declare const readEmbeddingRecovery: (lockDir: string) => ResolvedEmbeddingRecovery | undefined;

package/dist/storage/embedding-recovery.js

@@ -0,0 +1,146 @@
+/**
+ * Filesystem-only staged embedding provenance. Keep this independent of native
+ * and model imports: every index-lock caller needs the retention decision.
+ */
+import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync, realpathSync, } from 'node:fs';
+import path from 'node:path';
+import { INDEX_METADATA_FILE, LEGACY_METADATA_FILE } from './storage-constants.js';
+const STAGING_FILENAME = /^lbug\.staging\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+export const FAMILY_SUFFIXES = [
+    '',
+    '.wal',
+    '.shadow',
+    '.wal.checkpoint',
+    '.lock',
+    '.checkpoint.intent.lock',
+    '.checkpoint.apply.lock',
+];
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const isNonemptyString = (value) => typeof value === 'string' && value.length > 0;
+const isNodeIds = (value) => Array.isArray(value) && value.every(isNonemptyString);
+const isCount = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+/**
+ * Resolve only an explicit interrupted-generation receipt in this canonical
+ * slot. This validates provenance, not native contents or current identity;
+ * those checks must pass separately before any rows can be reused.
+ */
+export const resolveEmbeddingRecovery = (lockDir, checkpoint) => {
+    if (!isRecord(checkpoint) || !isRecord(checkpoint.recovery))
+        return undefined;
+    if (checkpoint.kind !== undefined && checkpoint.kind !== 'interrupted')
+        return undefined;
+    if (!isNonemptyString(checkpoint.at) ||
+        !Number.isFinite(Date.parse(checkpoint.at)) ||
+        !isCount(checkpoint.nodesProcessed) ||
+        !isCount(checkpoint.totalNodes) ||
+        checkpoint.nodesProcessed > checkpoint.totalNodes ||
+        !isCount(checkpoint.chunksProcessed) ||
+        !isNonemptyString(checkpoint.model) ||
+        !isCount(checkpoint.dimensions) ||
+        checkpoint.dimensions === 0 ||
+        !isNonemptyString(checkpoint.provider) ||
+        (checkpoint.pendingNodeIds !== undefined && !isNodeIds(checkpoint.pendingNodeIds))) {
+        return undefined;
+    }
+    const recovery = checkpoint.recovery;
+    if (!isNonemptyString(recovery.stagingFile) ||
+        !STAGING_FILENAME.test(recovery.stagingFile) ||
+        !isNonemptyString(recovery.schemaFingerprint) ||
+        !isNodeIds(recovery.unsafeNodeIds)) {
+        return undefined;
+    }
+    const unsafeNodeIds = new Set(recovery.unsafeNodeIds);
+    if (isNodeIds(checkpoint.pendingNodeIds) &&
+        checkpoint.pendingNodeIds.some((nodeId) => !unsafeNodeIds.has(nodeId))) {
+        return undefined;
+    }
+    try {
+        const canonicalDir = realpathSync(lockDir);
+        if (!lstatSync(canonicalDir).isDirectory())
+            return undefined;
+        const familyFiles = FAMILY_SUFFIXES.map((suffix) => recovery.stagingFile + suffix);
+        for (const [index, filename] of familyFiles.entries()) {
+            try {
+                // lstat refuses both live and dangling symlinks, without following one
+                // to a database outside the slot. The base file must exist.
+                if (!lstatSync(path.join(canonicalDir, filename)).isFile())
+                    return undefined;
+            }
+            catch (error) {
+                if (index > 0 && error.code === 'ENOENT')
+                    continue;
+                return undefined;
+            }
+        }
+        return {
+            dbPath: path.join(canonicalDir, recovery.stagingFile),
+            stagingFile: recovery.stagingFile,
+            schemaFingerprint: recovery.schemaFingerprint,
+            unsafeNodeIds: [...unsafeNodeIds],
+            familyFiles,
+        };
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Synchronous mirror of loadMeta's primary-first, absent-only fallback rule. */
+export const readEmbeddingRecovery = (lockDir) => {
+    let metadataPath = path.join(lockDir, INDEX_METADATA_FILE);
+    let descriptor;
+    const noFollow = constants.O_NOFOLLOW ?? 0;
+    const flags = constants.O_RDONLY | noFollow | (constants.O_NONBLOCK ?? 0);
+    try {
+        try {
+            descriptor = openSync(metadataPath, flags);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT' && code !== 'ENOTDIR')
+                return undefined;
+            // Windows cannot open with O_NOFOLLOW: an open of a dangling symlink
+            // reports ENOENT, but that existing primary entry must prevent fallback.
+            try {
+                lstatSync(metadataPath);
+                return undefined;
+            }
+            catch (statError) {
+                const statCode = statError.code;
+                if (statCode !== 'ENOENT' && statCode !== 'ENOTDIR')
+                    return undefined;
+            }
+            metadataPath = path.join(lockDir, LEGACY_METADATA_FILE);
+            descriptor = openSync(metadataPath, flags);
+        }
+        const opened = fstatSync(descriptor, { bigint: true });
+        const entry = lstatSync(metadataPath, { bigint: true });
+        // Check the opened file itself and match the current non-symlink entry.
+        // This also refuses replacement on platforms without O_NOFOLLOW.
+        if (!opened.isFile() ||
+            !entry.isFile() ||
+            (noFollow === 0 && opened.ino === 0n) ||
+            opened.dev !== entry.dev ||
+            opened.ino !== entry.ino) {
+            return undefined;
+        }
+        const meta = JSON.parse(readFileSync(descriptor, 'utf8'));
+        if (!isRecord(meta))
+            return undefined;
+        // storagePath describes the flat/cache root, including in branch-slot
+        // metadata. The current locked directory is the generation boundary.
+        return resolveEmbeddingRecovery(lockDir, meta.embeddingCheckpoint);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (descriptor !== undefined) {
+            try {
+                closeSync(descriptor);
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+    }
+};

package/dist/storage/index-lock.d.ts

@@ -95,8 +95,9 @@ export declare const isLockUnwritableCode: (code: string | undefined) => boolean
 /**
  * Delete orphaned build/staging artifacts left in the lock directory by a
  * crashed prior writer. Safe precisely because we hold the exclusive lock: no
- * other writer can be creating these here right now, so anything present is a
- * crash orphan. Matches this slot's staging files ONLY — never `lbug` itself,
+ * other writer can be creating these here right now. A checkpoint-referenced
+ * generation is retained for embedding recovery; all other stages are orphans.
+ * Matches this slot's staging files ONLY — never `lbug` itself,
  * never `lbug.wal`/`lbug.shadow` (the LIVE index's own sidecars), and never a
  * `branches/<slug>/` sub-slot (which owns its own lock + sweep). Non-recursive.
  */

package/dist/storage/index-lock.js

@@ -52,6 +52,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { randomBytes, randomUUID, createHash } from 'node:crypto';
 import { isProcessAlive } from '../utils/process-identity.js';
+import { readEmbeddingRecovery } from './embedding-recovery.js';
 const LOCK_FILENAME = 'analyze.lock';
 const LOCK_RECORD_VERSION = 1;
 const lockGuardPath = (lockPath) => `${lockPath}.guard`;
@@ -304,8 +305,9 @@ const deniedCreateHandle = (lockPath, record, error) => {
 /**
  * Delete orphaned build/staging artifacts left in the lock directory by a
  * crashed prior writer. Safe precisely because we hold the exclusive lock: no
- * other writer can be creating these here right now, so anything present is a
- * crash orphan. Matches this slot's staging files ONLY — never `lbug` itself,
+ * other writer can be creating these here right now. A checkpoint-referenced
+ * generation is retained for embedding recovery; all other stages are orphans.
+ * Matches this slot's staging files ONLY — never `lbug` itself,
  * never `lbug.wal`/`lbug.shadow` (the LIVE index's own sidecars), and never a
  * `branches/<slug>/` sub-slot (which owns its own lock + sweep). Non-recursive.
  */
@@ -313,6 +315,7 @@ export const sweepStagingArtifacts = (lockDir, log) => {
     // Matches `lbug.new`, `lbug.new.wal`, `lbug.staging.<id>`, `lbug.staging.<id>.wal`, …
     // Does NOT match `lbug`, `lbug.wal`, `lbug.shadow`.
     const stagingRe = /^lbug\.(staging\..+|new(\..+)?)$/;
+    const retained = new Set(readEmbeddingRecovery(lockDir)?.familyFiles ?? []);
     let removed = 0;
     let entries;
     try {
@@ -322,7 +325,7 @@ export const sweepStagingArtifacts = (lockDir, log) => {
         return;
     }
     for (const name of entries) {
-        if (!stagingRe.test(name))
+        if (!stagingRe.test(name) || retained.has(name))
             continue;
         try {
             unlinkSync(path.join(lockDir, name));

package/dist/storage/repo-meta.d.ts

@@ -35,6 +35,14 @@ export { GITNEXUS_DIR, INDEX_METADATA_FILE, LEGACY_METADATA_FILE } from './stora
 export type ContentRetention = 'full' | 'symbol' | 'none';
 export type FtsProfile = 'full' | 'symbol-no-file-content' | 'name-only';
 export declare const CONTENT_RETENTION_SCHEMA_VERSION = 1;
+/** Exact staged generation whose completed embedding groups can survive a retry. */
+export interface EmbeddingRecoveryReference {
+    /** A run-minted basename within this metadata file's index slot. */
+    stagingFile: string;
+    schemaFingerprint: string;
+    /** Active-window and inherited incomplete groups: never reusable until completed. */
+    unsafeNodeIds: string[];
+}
 /**
  * Versioned receipt for the analyzer process that produced an index.
  *
@@ -511,6 +519,11 @@ export interface RepoMeta {
          * subset of their chunks; for `'partial'` they hold none.
          */
         pendingNodeIds?: string[];
+        /**
+         * Interrupted atomic builds only. This does not publish the staged graph
+         * or advance live embedding statistics; it identifies a recovery source.
+         */
+        recovery?: EmbeddingRecoveryReference;
     };
     /**
      * Name of the git branch this index represents (#2106). Absent for the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.71",
+  "version": "1.6.13-rc.73",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",