gitnexus 1.6.13-rc.7 → 1.6.13-rc.9

package/README.md

@@ -325,6 +325,10 @@ analyze_failure_threshold: 3
 projects:
   - local_path: /abs/path/to/repos
     branches: [master, main]
+    # pdg: omit = preserve live index mode; true = keep PDG current;
+    # false = init default (warns, then strips PDG on the next successful rebuild).
+    # Do not paste pdg: false onto an existing watch file unless you intend to drop PDG.
+    pdg: false
     overwrite_local_changes: false
     remote_urls:
       - git@github.com:owner/repo.git
@@ -332,7 +336,9 @@ projects:
       - git@gitee.com:owner/repo.git
 ```
 
-`sync_interval_minutes` must be an integer of at least `5`. `local_path` must be an absolute path without traversal; each remote is cloned below it as `host/namespace/repo`, preventing same-basename repositories from colliding. `remote_urls` must use SSH SCP form for github.com, gitlab.com, or gitee.com. `repo_git_timeout` applies to each repo clone/pull and defaults to `10s`; a bare number such as `10` is interpreted as seconds, while `10000ms`, `10s`, and `1m` keep their explicit units. It must not exceed one hour or `sync_interval_minutes`, whichever is smaller — so a bare `600000` is rejected, because it means 600000 seconds rather than milliseconds. `analyze_timeout` applies to each isolated analysis worker, defaults to half of `sync_interval_minutes`, and cannot exceed that value; this keeps it within Node's timer range. Timeout and `auto-sync stop` request safe cancellation; a worker already in native work exits after it returns to a JS-visible safe point. While waiting, auto-sync reports `cancelling` or `stopping` and keeps its ownership files so another auto-sync cannot take over. The parent waits up to 5 seconds for the worker to exit; after that it stops waiting, releases its ownership files, and leaves the worker to finish and exit on its own rather than killing it mid-write. `auto-sync stop` uses this same control path on macOS and Windows. `overwrite_local_changes` defaults to `false`; a dirty local clone is skipped with an error log, while `true` allows branch fallback to replace local changes and additionally discards untracked files and directories in the clone after checkout — ignored paths, including GitNexus's own `.gitnexus/` storage, are preserved. `max_concurrency` defaults to `1` and is capped at runtime by `floor(availableMemoryGB / 2)` with a minimum of `1`; the effective value is printed at the start of each loop. Each analysis worker's heap cap is the machine-wide cap divided by the number of repositories analyzed in parallel, so concurrent workers share one memory budget instead of each claiming the whole machine. `analyze_failure_threshold` defaults to `3`, must be at least `2`, and pauses repeated failures only for the same repo branch and commit; a new commit or `gitnexus auto-sync reset` clears the block and allows analysis again. Repositories are registered and added to groups by their full remote identity (`host/namespace/repo`), so repositories with the same basename remain distinct. Use `branches` to try branches in order; legacy `branch` remains supported, but the two fields cannot be set together. If all branches are unavailable or time out, watch logs an error, records the repo status, and skips that repo for the loop. Leave `group_name` empty or omit it to skip group add/sync for that project; otherwise create the group first with `gitnexus group create <name>`. `$GITNEXUS_HOME/watch/project_commit_info.txt` is for inspection only; GitNexus stores machine state separately in `$GITNEXUS_HOME/watch/auto-sync-state.json`.
+`sync_interval_minutes` must be an integer of at least `5`. `local_path` must be an absolute path without traversal; each remote is cloned below it as `host/namespace/repo`, preventing same-basename repositories from colliding. `remote_urls` must use SSH SCP form for github.com, gitlab.com, or gitee.com. `repo_git_timeout` applies to each repo clone/pull and defaults to `10s`; a bare number such as `10` is interpreted as seconds, while `10000ms`, `10s`, and `1m` keep their explicit units. It must not exceed one hour or `sync_interval_minutes`, whichever is smaller — so a bare `600000` is rejected, because it means 600000 seconds rather than milliseconds. `analyze_timeout` applies to each isolated analysis worker and defaults to half of `sync_interval_minutes`, but it is independent of polling and may be longer, up to Node's timer limit (`2147483647ms`). A `5` minute poll with `analyze_timeout: 30m` is valid. A tick that arrives while the previous loop is active never overlaps it: ticks coalesce into one immediate follow-up run, which pulls and analyzes the newest commit. If the parent times out and leaves that worker running, the follow-up is deferred to the next interval so a leftover lock holder is not counted as a hard analyze failure. Timeout and `auto-sync stop` request safe cancellation; a worker already in native work exits after it returns to a JS-visible safe point. While waiting, auto-sync reports `cancelling` or `stopping` and keeps its ownership files so another auto-sync cannot take over. The parent waits up to 5 seconds for the worker to exit; after that it stops waiting, releases its ownership files, and leaves the worker to finish and exit on its own rather than killing it mid-write. `auto-sync stop` uses this same control path on macOS and Windows.
+
+`pdg` is configured per project. `pdg: true` builds and maintains the full CFG, control-dependence, reaching-definition, and taint layers on both initial and incremental analyses. Auto-sync requests staged atomic incremental publication where the analyzer supports it: the old graph remains available to readers until the replacement succeeds, and analysis errors are recorded while the old graph remains intact. Unsupported paths retain the analyzer's existing in-place behavior. Untouched configs that omit `pdg` preserve the existing index mode and cannot silently strip PDG data. Do not paste `pdg: false` from this example onto an existing watch file unless you intend to drop PDG. An explicit `pdg: false` disables PDG and emits a warning before a successful rebuild removes those layers. `overwrite_local_changes` defaults to `false`; a dirty local clone is skipped with an error log, while `true` allows branch fallback to replace local changes and additionally discards untracked files and directories in the clone after checkout — ignored paths, including GitNexus's own `.gitnexus/` storage, are preserved. `max_concurrency` defaults to `1` and is capped at runtime by `floor(availableMemoryGB / 2)` with a minimum of `1`; the effective value is printed at the start of each loop. Each analysis worker's heap cap is the machine-wide cap divided by the number of repositories analyzed in parallel, so concurrent workers share one memory budget instead of each claiming the whole machine. `analyze_failure_threshold` defaults to `3`, must be at least `2`, and pauses repeated failures only for the same repo branch, commit, and requested PDG mode; a new commit, a PDG mode change, or `gitnexus auto-sync reset` clears the block and allows analysis again. Repositories are registered and added to groups by their full remote identity (`host/namespace/repo`), so repositories with the same basename remain distinct. Use `branches` to try branches in order; legacy `branch` remains supported, but the two fields cannot be set together. If all branches are unavailable or time out, watch logs an error, records the repo status, and skips that repo for the loop. Leave `group_name` empty or omit it to skip group add/sync for that project; otherwise create the group first with `gitnexus group create <name>`. `$GITNEXUS_HOME/watch/project_commit_info.txt` is for inspection only; GitNexus stores machine state separately in `$GITNEXUS_HOME/watch/auto-sync-state.json`.
 
 GraphQL contract matching is opt-in in the group's `group.yaml`:
 
@@ -431,7 +437,7 @@ TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Kotlin, Swift,
 | Kotlin     | ✓       | ✓              | ✓       | ✓        | ✓                | ✓                     | —      | ✓          | ✓            |
 | C#         | ✓       | ✓              | ✓       | ✓        | ✓                | ✓                     | ✓      | ✓          | ✓            |
 | Go         | ✓       | —              | ✓       | ✓        | ✓                | ✓                     | ✓      | ✓          | ✓            |
-| Rust       | ✓       | ✓              | ✓       | ✓        | ✓                | ✓                     | —      | ✓          | ✓            |
+| Rust       | ✓       | ✓              | ✓       | ✓        | ✓                | ✓                     | ✓      | ✓          | ✓            |
 | PHP        | ✓       | ✓              | ✓       | —        | ✓                | ✓                     | ✓      | ✓          | ✓            |
 | Ruby       | ✓       | —              | ✓       | ✓        | —                | ✓                     | —      | ✓          | ✓            |
 | Swift      | —       | —              | ✓       | ✓        | ✓                | ✓                     | ✓      | ✓          | ✓            |

package/dist/cli/auto-sync.js

@@ -99,6 +99,10 @@ function defaultSyncConfig(localPath) {
         'projects:',
         `  - local_path: ${localPath}`,
         '    branches: [master, main]',
+        '    # pdg: omit = preserve live index mode; true = keep PDG current;',
+        '    # false = init default (warns, then strips PDG on the next successful rebuild).',
+        '    # Do not paste pdg: false onto an existing watch file unless you intend to drop PDG.',
+        '    pdg: false',
         '    overwrite_local_changes: false',
         '    remote_urls:',
         '      - git@github.com:owner/repo.git',

package/dist/core/auto-sync/analysis-worker-launch.d.ts

@@ -9,6 +9,16 @@ interface AnalysisWorker extends Pick<ChildProcess, 'send' | 'on'> {
         unref(): void;
     } | null;
 }
+export declare class AutoSyncAnalysisError extends Error {
+    readonly code?: 'index-lock-timeout';
+    readonly retryable?: boolean;
+    readonly abandonedWorker: boolean;
+    constructor(message: string, options?: {
+        code?: 'index-lock-timeout';
+        retryable?: boolean;
+        abandonedWorker?: boolean;
+    });
+}
 export interface AutoSyncAnalysisLaunchDeps {
     forkWorker: (workerPath: string, execArgv: string[]) => AnalysisWorker;
     setTimeoutFn: typeof setTimeout;

package/dist/core/auto-sync/analysis-worker-launch.js

@@ -12,6 +12,18 @@ const _require = createRequire(import.meta.url);
  * past its safe point still turns `watch stop` into a timeout.
  */
 const AUTO_SYNC_CANCEL_GRACE_MS = 5_000;
+export class AutoSyncAnalysisError extends Error {
+    code;
+    retryable;
+    abandonedWorker;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = 'AutoSyncAnalysisError';
+        this.code = options.code;
+        this.retryable = options.retryable;
+        this.abandonedWorker = options.abandonedWorker === true;
+    }
+}
 const DEFAULT_DEPS = {
     forkWorker: (workerPath, execArgv) => fork(workerPath, [], {
         execArgv,
@@ -111,8 +123,8 @@ export function createAutoSyncAnalysisRunner(overrides = {}) {
                 if (settled)
                     return;
                 releaseChild();
-                settle(new Error(`${error.message} The analyze worker did not exit within ${deps.cancelGraceMs}ms; ` +
-                    'it was left running so its native work is not interrupted.'));
+                settle(new AutoSyncAnalysisError(`${error.message} The analyze worker did not exit within ${deps.cancelGraceMs}ms; ` +
+                    'it was left running so its native work is not interrupted.', { abandonedWorker: true, retryable: true }));
             }, deps.cancelGraceMs);
         };
         const timeout = deps.setTimeoutFn(() => requestCancellation(new Error(`Analysis timed out after ${timeoutMs}ms.`)), timeoutMs);
@@ -148,7 +160,10 @@ export function createAutoSyncAnalysisRunner(overrides = {}) {
                 return;
             }
             if (terminalOutcome?.type === 'error') {
-                settle(new Error(terminalOutcome.message));
+                settle(new AutoSyncAnalysisError(terminalOutcome.message, {
+                    code: terminalOutcome.code,
+                    retryable: terminalOutcome.retryable,
+                }));
                 return;
             }
             settle(new Error(`Auto-sync analyze worker exited before completion (${childSignal ?? code ?? 'unknown'}).`));

package/dist/core/auto-sync/config.d.ts

@@ -3,6 +3,8 @@ export declare const DEFAULT_ANALYZE_FAILURE_THRESHOLD = 3;
 export interface AutoSyncProjectConfig {
     localPath: string;
     groupName?: string;
+    /** Explicit opt-in/out. Omitted legacy configs preserve the index's current mode. */
+    pdg?: boolean;
     overwriteLocalChanges: boolean;
     branches: string[];
     remoteUrls: string[];

package/dist/core/auto-sync/config.js

@@ -127,19 +127,19 @@ export function parseAutoSyncConfig(content, configPath) {
             `sync_interval_minutes); a bare number is interpreted as seconds, so use an explicit ` +
             `unit such as 600000ms or 10m`);
     }
-    const maxAnalyzeTimeoutMs = Number.isInteger(interval) &&
+    const defaultAnalyzeTimeoutMs = Number.isInteger(interval) &&
         interval >= MIN_SYNC_INTERVAL_MINUTES &&
         interval <= MAX_SYNC_INTERVAL_MINUTES
         ? interval * 30_000
         : undefined;
     const analyzeTimeoutMs = raw.analyze_timeout === undefined
-        ? (maxAnalyzeTimeoutMs ?? 0)
+        ? (defaultAnalyzeTimeoutMs ?? 0)
         : parseDurationMs(raw.analyze_timeout);
     if (!Number.isInteger(analyzeTimeoutMs) || analyzeTimeoutMs <= 0) {
         errors.push('analyze_timeout must be a positive duration such as 30m');
     }
-    else if (maxAnalyzeTimeoutMs !== undefined && analyzeTimeoutMs > maxAnalyzeTimeoutMs) {
-        errors.push(`analyze_timeout must not exceed half of sync_interval_minutes (${maxAnalyzeTimeoutMs / 60_000}m)`);
+    else if (analyzeTimeoutMs > MAX_TIMER_DELAY_MS) {
+        errors.push(`analyze_timeout must not exceed ${MAX_TIMER_DELAY_MS}ms`);
     }
     const analyzeFailureThreshold = raw.analyze_failure_threshold === undefined
         ? DEFAULT_ANALYZE_FAILURE_THRESHOLD
@@ -210,10 +210,14 @@ export function parseAutoSyncConfig(content, configPath) {
             if (typeof overwriteLocalChanges !== 'boolean') {
                 errors.push(`projects[${index}].overwrite_local_changes must be a boolean`);
             }
+            if (project.pdg !== undefined && typeof project.pdg !== 'boolean') {
+                errors.push(`projects[${index}].pdg must be a boolean`);
+            }
             if (localPath && remoteUrls.length > 0 && branches.length > 0) {
                 projects.push({
                     localPath,
                     groupName,
+                    ...(typeof project.pdg === 'boolean' ? { pdg: project.pdg } : {}),
                     overwriteLocalChanges: overwriteLocalChanges === true,
                     branches,
                     remoteUrls,

package/dist/core/auto-sync/runner.d.ts

@@ -13,6 +13,7 @@ export interface AutoSyncRunDeps {
     cloneOrPull: typeof cloneOrPull;
     getCurrentBranch: (repoPath: string, timeoutMs: number) => Promise<string | undefined>;
     getCurrentCommit: (repoPath: string, timeoutMs: number) => Promise<string>;
+    getExistingPdgMode: (repoPath: string, branch: string) => Promise<boolean>;
     runAnalysis: AutoSyncAnalysisRunner;
     registerRepo: typeof registerRepo;
     resolveBranchPlacement: typeof resolveBranchPlacement;
@@ -29,6 +30,8 @@ export interface AutoSyncRunResult {
     analyzed: number;
     skippedAnalysis: number;
     failed: number;
+    /** True when a timed-out analyze worker was left running and may still hold the index lock. */
+    abandonedAnalysisWorker?: boolean;
 }
 export declare function runAutoSyncOnce(config: AutoSyncConfig, options?: {
     deps?: Partial<AutoSyncRunDeps>;

package/dist/core/auto-sync/runner.js

@@ -4,13 +4,13 @@ import { createRequire } from 'node:module';
 import { loadGroupConfig } from '../group/config-parser.js';
 import { getDefaultGitnexusDir, getGroupDir } from '../group/storage.js';
 import { syncGroup } from '../group/sync.js';
-import { registerRepo, resolveBranchPlacement } from '../../storage/repo-manager.js';
+import { getStoragePaths, loadMeta, registerRepo, resolveBranchPlacement, } from '../../storage/repo-manager.js';
 import { extractRepoNameFromRemoteUrl } from './repo.js';
 import { cloneOrPull, runGit } from '../../server/git-clone.js';
 import { resolveConfiguredCloneRoot } from './path-security.js';
 import { buildStateKey, loadAutoSyncState, saveAutoSyncState, shouldAnalyzeCommit, writeProjectCommitInfo, } from './state.js';
 import { validateAutoSyncRemoteUrl } from './config.js';
-import { runAutoSyncAnalysis } from './analysis-worker-launch.js';
+import { AutoSyncAnalysisError, runAutoSyncAnalysis, } from './analysis-worker-launch.js';
 const _require = createRequire(import.meta.url);
 const yaml = _require('js-yaml');
 const DEFAULT_LOGGER = {
@@ -25,6 +25,23 @@ const DEFAULT_DEPS = {
         return branch || undefined;
     },
     getCurrentCommit: async (repoPath, timeoutMs) => (await runGit(['rev-parse', 'HEAD'], repoPath, { timeoutMs })).trim(),
+    getExistingPdgMode: async (repoPath, branch) => {
+        const placement = await resolveBranchPlacement(repoPath, branch);
+        const paths = getStoragePaths(repoPath, placement.branch);
+        const meta = await loadMeta(path.dirname(paths.metaPath));
+        if (meta)
+            return meta.pdg !== undefined;
+        try {
+            await fs.stat(paths.lbugPath);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT' || code === 'ENOTDIR')
+                return false;
+            throw error;
+        }
+        throw new Error(`Cannot determine whether the existing index at ${paths.lbugPath} contains PDG data because its metadata is missing or unreadable.`);
+    },
     runAnalysis: runAutoSyncAnalysis,
     registerRepo,
     resolveBranchPlacement,
@@ -46,6 +63,7 @@ export async function runAutoSyncOnce(config, options = {}) {
     const groupsToSync = new Set();
     const groupStateKeys = new Map();
     const result = { synced: 0, analyzed: 0, skippedAnalysis: 0, failed: 0 };
+    let abandonedAnalysisWorker = false;
     const commitInfoEntries = [];
     const actualConcurrency = resolveActualConcurrency(config.maxConcurrency, deps.getAvailableMemoryGB());
     logger.info(`[auto-sync] Starting sync loop with max_concurrency=${actualConcurrency} analyze_failure_threshold=${config.analyzeFailureThreshold}.`);
@@ -88,27 +106,58 @@ export async function runAutoSyncOnce(config, options = {}) {
             const currentCommit = await deps.getCurrentCommit(targetDir, config.repoGitTimeoutMs);
             const stateKey = buildStateKey(targetDir, currentBranch);
             const previous = state[stateKey];
+            let existingPdg;
+            try {
+                existingPdg = await deps.getExistingPdgMode(targetDir, currentBranch);
+            }
+            catch (error) {
+                if (item.project.pdg === undefined) {
+                    throw new Error(`${error instanceof Error ? error.message : String(error)} ` +
+                        'Refusing to analyze so the live graph is preserved.');
+                }
+                logger.warn(`[auto-sync] Existing PDG mode could not be determined for ${targetDir}; ` +
+                    `applying explicit pdg=${item.project.pdg}.`);
+            }
+            const requestedPdg = item.project.pdg ?? existingPdg;
+            const pdgModeChanged = existingPdg === undefined || requestedPdg !== existingPdg;
             let analyzeStatus = 'skipped';
             let analyzedCommitId = previous?.analyzedCommitId;
             let analyzeConsecutiveFailures = previous?.analyzeConsecutiveFailures ?? 0;
             let lastAnalyzeError = previous?.lastAnalyzeError;
             const groupSyncPending = previous?.groupSyncPending === true;
             let stats;
-            if (previous && previous.codeCommitId !== currentCommit) {
+            const previousRequestedPdg = previous?.requestedPdg ?? existingPdg;
+            if (previous &&
+                (previous.codeCommitId !== currentCommit || previousRequestedPdg !== requestedPdg)) {
                 analyzeConsecutiveFailures = 0;
                 lastAnalyzeError = undefined;
             }
+            if (item.project.pdg === undefined && existingPdg) {
+                logger.info(`[auto-sync] Preserving existing PDG mode for ${targetDir}; project configuration does not set pdg.`);
+            }
+            else if (item.project.pdg === false && existingPdg) {
+                logger.warn(`[auto-sync] PDG is explicitly disabled for ${targetDir}; the next successful rebuild will remove existing PDG data.`);
+            }
             if (analyzeConsecutiveFailures >= config.analyzeFailureThreshold) {
                 analyzeStatus = 'threshold_skipped';
                 logger.error(`[auto-sync] Skip analysis for ${targetDir}; analyze consecutive failures ${analyzeConsecutiveFailures}/${config.analyzeFailureThreshold} reached threshold. Fix the repository or clear auto-sync state before retrying.`);
             }
-            else if (shouldAnalyzeCommit({
-                currentCommit,
-                previousAnalyzedCommit: previous?.analyzedCommitId,
-                previousStatus: previous?.lastAnalyzeStatus,
-            })) {
+            else if (pdgModeChanged ||
+                shouldAnalyzeCommit({
+                    currentCommit,
+                    previousAnalyzedCommit: previous?.analyzedCommitId,
+                    previousStatus: previous?.lastAnalyzeStatus,
+                })) {
                 try {
-                    const analysis = await deps.runAnalysis(targetDir, { branch: currentBranch, skipAgentsMd: true, skipSkills: true }, config.analyzeTimeoutMs, options.signal, options.onAnalysisCancellationRequested, analysisParallelism);
+                    const analysis = await deps.runAnalysis(targetDir, {
+                        branch: currentBranch,
+                        skipAgentsMd: true,
+                        skipSkills: true,
+                        ...(item.project.pdg === undefined
+                            ? { preserveExistingPdg: true }
+                            : { pdg: requestedPdg }),
+                        atomicIncremental: true,
+                    }, config.analyzeTimeoutMs, options.signal, options.onAnalysisCancellationRequested, analysisParallelism);
                     throwIfAborted(options.signal);
                     stats = analysis.stats;
                     analyzeStatus = 'success';
@@ -120,13 +169,20 @@ export async function runAutoSyncOnce(config, options = {}) {
                     if (options.signal?.aborted)
                         throw err;
                     analyzeStatus = 'failed';
-                    analyzeConsecutiveFailures += 1;
                     lastAnalyzeError = shortErrorMessage(err);
-                    logger.error(`[auto-sync] Analysis failed for ${targetDir}; consecutive failures ${analyzeConsecutiveFailures}/${config.analyzeFailureThreshold}: ${lastAnalyzeError}`);
+                    if (isAbandonedAnalyzeWorkerError(err))
+                        abandonedAnalysisWorker = true;
+                    if (isRetryableAnalyzeContention(err)) {
+                        logger.error(`[auto-sync] Analysis failed for ${targetDir}; retryable leftover-worker or index-lock wait (not counted toward threshold): ${lastAnalyzeError}`);
+                    }
+                    else {
+                        analyzeConsecutiveFailures += 1;
+                        logger.error(`[auto-sync] Analysis failed for ${targetDir}; consecutive failures ${analyzeConsecutiveFailures}/${config.analyzeFailureThreshold}: ${lastAnalyzeError}`);
+                    }
                 }
             }
             else {
-                logger.info(`[auto-sync] Skip analysis for ${targetDir}; commit unchanged.`);
+                logger.info(`[auto-sync] Skip analysis for ${targetDir}; commit and PDG mode unchanged.`);
             }
             throwIfAborted(options.signal);
             return {
@@ -141,6 +197,7 @@ export async function runAutoSyncOnce(config, options = {}) {
                 analyzeStatus,
                 analyzeConsecutiveFailures,
                 lastAnalyzeError,
+                requestedPdg,
                 groupSyncPending,
                 stats,
                 stateKey,
@@ -220,6 +277,7 @@ export async function runAutoSyncOnce(config, options = {}) {
             codeCommitId: repoResult.currentCommit,
             analyzedCommitId,
             lastAnalyzeStatus: analyzeStatus,
+            requestedPdg: repoResult.requestedPdg,
             analyzeConsecutiveFailures,
             lastAnalyzeError,
             groupSyncPending: repoResult.groupSyncPending,
@@ -287,12 +345,27 @@ export async function runAutoSyncOnce(config, options = {}) {
     }
     if (groupStateChanged)
         await deps.saveState(state);
+    if (abandonedAnalysisWorker)
+        result.abandonedAnalysisWorker = true;
     return result;
 }
 function shortErrorMessage(err) {
     const message = err instanceof Error ? err.message : String(err);
     return message.replace(/\s+/g, ' ').slice(0, 240);
 }
+const ABANDONED_WORKER_MARKER = 'it was left running so its native work is not interrupted';
+function isAbandonedAnalyzeWorkerError(err) {
+    if (err instanceof AutoSyncAnalysisError && err.abandonedWorker)
+        return true;
+    return err instanceof Error && err.message.includes(ABANDONED_WORKER_MARKER);
+}
+function isRetryableAnalyzeContention(err) {
+    if (isAbandonedAnalyzeWorkerError(err))
+        return true;
+    return (err instanceof AutoSyncAnalysisError &&
+        err.code === 'index-lock-timeout' &&
+        err.retryable === true);
+}
 export function getConfiguredRepoPath(project, repoName, remoteUrl) {
     if (!remoteUrl)
         return path.resolve(project.localPath, repoName);

package/dist/core/auto-sync/starter.js

@@ -66,6 +66,7 @@ export async function startAutoSyncWatch(options = {}) {
         let activeRun;
         let activeAbortController;
         let stopping = false;
+        let rerunRequested = false;
         let statusWrite = Promise.resolve();
         const updateStatus = (state, message) => {
             const write = statusWrite.then(() => writeWatchStatus(paths, {
@@ -86,10 +87,12 @@ export async function startAutoSyncWatch(options = {}) {
             if (stopping)
                 return;
             if (activeRun) {
-                stderr.write('[auto-sync] Previous run is still active; skipping overlapping run.\n');
+                rerunRequested = true;
+                stderr.write('[auto-sync] Previous run is still active; queued one immediate follow-up.\n');
                 return;
             }
             const startedAt = new Date();
+            let deferFollowUp = false;
             stderr.write(`[auto-sync] Watch loop started at ${startedAt.toISOString()}.\n`);
             const abortController = new AbortController();
             const run = runOnce(loaded.config, {
@@ -101,6 +104,7 @@ export async function startAutoSyncWatch(options = {}) {
                 },
             })
                 .then((result) => {
+                deferFollowUp = result.abandonedAnalysisWorker === true;
                 stderr.write(`[auto-sync] Watch loop finished: synced=${result.synced} analyzed=${result.analyzed} skipped=${result.skippedAnalysis} failed=${result.failed}.\n`);
             })
                 .catch((err) => {
@@ -108,6 +112,8 @@ export async function startAutoSyncWatch(options = {}) {
                 stderr.write('[auto-sync] Watch loop finished: failed.\n');
             })
                 .finally(async () => {
+                const runAgain = rerunRequested;
+                rerunRequested = false;
                 if (activeRun === run) {
                     activeRun = undefined;
                     activeAbortController = undefined;
@@ -115,6 +121,14 @@ export async function startAutoSyncWatch(options = {}) {
                 if (!stopping) {
                     await updateStatus('running').catch(reportStatusWriteFailure);
                 }
+                if (runAgain && !stopping && !activeRun) {
+                    if (deferFollowUp) {
+                        stderr.write('[auto-sync] Previous run left an analyze worker running; deferring the coalesced follow-up to the next interval.\n');
+                    }
+                    else {
+                        runSafely();
+                    }
+                }
             });
             activeRun = run;
             activeAbortController = abortController;
@@ -122,6 +136,7 @@ export async function startAutoSyncWatch(options = {}) {
         let stopPromise;
         const stop = () => (stopPromise ??= (async () => {
             stopping = true;
+            rerunRequested = false;
             clearIntervalFn(timer);
             clearIntervalFn(controlTimer);
             activeAbortController?.abort();

package/dist/core/auto-sync/state.d.ts

@@ -3,6 +3,11 @@ export interface AutoSyncCommitStateEntry {
     codeCommitId: string;
     analyzedCommitId?: string;
     lastAnalyzeStatus?: AutoSyncAnalyzeStatus;
+    /**
+     * PDG mode from the most recent successful sync result. Written even when
+     * analysis was threshold-skipped and `runAnalysis` did not run.
+     */
+    requestedPdg?: boolean;
     analyzeConsecutiveFailures?: number;
     lastAnalyzeError?: string;
     groupSyncPending?: boolean;

package/dist/core/auto-sync/state.js

@@ -78,6 +78,7 @@ function isAutoSyncCommitStateEntry(value) {
             entry.lastAnalyzeStatus === 'failed' ||
             entry.lastAnalyzeStatus === 'skipped' ||
             entry.lastAnalyzeStatus === 'threshold_skipped') &&
+        (entry.requestedPdg === undefined || typeof entry.requestedPdg === 'boolean') &&
         (entry.analyzeConsecutiveFailures === undefined ||
             (typeof entry.analyzeConsecutiveFailures === 'number' &&
                 Number.isInteger(entry.analyzeConsecutiveFailures) &&

package/dist/core/ingestion/languages/rust/cargo-module-files.d.ts

@@ -0,0 +1,9 @@
+import type Parser from 'tree-sitter';
+/** Public use evidence from the same AST used for membership. Keeps restricted
+ * and private globs distinct without changing the shared import/cache shape. */
+export declare function rustPublicUses(root: Parser.SyntaxNode): ReadonlySet<string>;
+/** External modules reachable from one source file; undefined is incomplete. */
+export declare function rustModuleFiles(root: Parser.SyntaxNode, file: string, ownsDirectory: boolean, files: ReadonlySet<string>, missingFiles?: Set<string>, isCrateRoot?: boolean): readonly {
+    file: string;
+    ownsDirectory: boolean;
+}[] | undefined;