preflight-mcp 0.1.3 → 0.1.5

package/dist/bundle/service.js

@@ -14,6 +14,7 @@ import { ingestContext7Libraries } from './context7.js';
 import { analyzeBundleStatic } from './analysis.js';
 import { autoDetectTags, generateDisplayName, generateDescription } from './tagging.js';
 import { bundleCreationLimiter } from '../core/concurrency-limiter.js';
+import { getProgressTracker, calcPercent } from '../jobs/progressTracker.js';
 const DEDUP_INDEX_FILE = '.preflight-dedup-index.json';
 function sha256Hex(text) {
     return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
@@ -90,7 +91,7 @@ async function writeDedupIndex(storageDir, idx) {
         throw err;
     }
 }
-async function updateDedupIndexBestEffort(cfg, fingerprint, bundleId, bundleUpdatedAt) {
+async function updateDedupIndexBestEffort(cfg, fingerprint, bundleId, bundleUpdatedAt, status = 'complete') {
     for (const storageDir of cfg.storageDirs) {
         try {
             const parentAvailable = await isParentAvailable(storageDir);
@@ -98,7 +99,7 @@ async function updateDedupIndexBestEffort(cfg, fingerprint, bundleId, bundleUpda
                 continue;
             await ensureDir(storageDir);
             const idx = await readDedupIndex(storageDir);
-            idx.byFingerprint[fingerprint] = { bundleId, bundleUpdatedAt };
+            idx.byFingerprint[fingerprint] = { bundleId, bundleUpdatedAt, status };
             idx.updatedAt = nowIso();
             await writeDedupIndex(storageDir, idx);
         }
@@ -107,6 +108,97 @@ async function updateDedupIndexBestEffort(cfg, fingerprint, bundleId, bundleUpda
         }
     }
 }
+/**
+ * Set in-progress lock for a fingerprint. Returns false if already locked (not timed out).
+ */
+async function setInProgressLock(cfg, fingerprint, taskId, repos) {
+    const now = nowIso();
+    const nowMs = Date.now();
+    for (const storageDir of cfg.storageDirs) {
+        try {
+            if (!(await isPathAvailable(storageDir)))
+                continue;
+            await ensureDir(storageDir);
+            const idx = await readDedupIndex(storageDir);
+            const existing = idx.byFingerprint[fingerprint];
+            // Check if there's an existing in-progress lock
+            if (existing?.status === 'in-progress' && existing.startedAt) {
+                const startedMs = new Date(existing.startedAt).getTime();
+                const elapsed = nowMs - startedMs;
+                // If lock hasn't timed out, return the existing entry
+                if (elapsed < cfg.inProgressLockTimeoutMs) {
+                    return { locked: false, existingEntry: existing };
+                }
+                // Lock timed out - will be overwritten
+                logger.warn(`In-progress lock timed out for fingerprint ${fingerprint.slice(0, 8)}...`);
+            }
+            // Set new in-progress lock
+            idx.byFingerprint[fingerprint] = {
+                bundleId: '', // Will be set on completion
+                bundleUpdatedAt: now,
+                status: 'in-progress',
+                startedAt: now,
+                taskId,
+                repos,
+            };
+            idx.updatedAt = now;
+            await writeDedupIndex(storageDir, idx);
+            return { locked: true };
+        }
+        catch (err) {
+            logger.debug(`Failed to set in-progress lock in ${storageDir}`, err instanceof Error ? err : undefined);
+        }
+    }
+    // If we couldn't write to any storage, assume we can proceed (best-effort)
+    return { locked: true };
+}
+/**
+ * Clear in-progress lock (on failure or completion with status='complete').
+ */
+async function clearInProgressLock(cfg, fingerprint) {
+    for (const storageDir of cfg.storageDirs) {
+        try {
+            if (!(await isPathAvailable(storageDir)))
+                continue;
+            const idx = await readDedupIndex(storageDir);
+            const existing = idx.byFingerprint[fingerprint];
+            // Only clear if it's in-progress
+            if (existing?.status === 'in-progress') {
+                delete idx.byFingerprint[fingerprint];
+                idx.updatedAt = nowIso();
+                await writeDedupIndex(storageDir, idx);
+            }
+        }
+        catch (err) {
+            logger.debug(`Failed to clear in-progress lock in ${storageDir}`, err instanceof Error ? err : undefined);
+        }
+    }
+}
+/**
+ * Check if a fingerprint has an in-progress lock (not timed out).
+ */
+export async function checkInProgressLock(cfg, fingerprint) {
+    const nowMs = Date.now();
+    for (const storageDir of cfg.storageDirs) {
+        try {
+            if (!(await isPathAvailable(storageDir)))
+                continue;
+            const idx = await readDedupIndex(storageDir);
+            const existing = idx.byFingerprint[fingerprint];
+            if (existing?.status === 'in-progress' && existing.startedAt) {
+                const startedMs = new Date(existing.startedAt).getTime();
+                const elapsed = nowMs - startedMs;
+                if (elapsed < cfg.inProgressLockTimeoutMs) {
+                    return existing;
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return null;
+}
 async function readBundleSummary(cfg, bundleId) {
     const storageDir = (await findBundleStorageDir(cfg.storageDirs, bundleId)) ?? (await getEffectiveStorageDir(cfg));
     const paths = getBundlePaths(storageDir, bundleId);
@@ -137,6 +229,9 @@ async function findExistingBundleByFingerprint(cfg, fingerprint) {
                 continue;
             const idx = await readDedupIndex(storageDir);
             const hit = idx.byFingerprint[fingerprint];
+            // Skip in-progress entries - they don't have a completed bundle yet
+            if (hit?.status === 'in-progress')
+                continue;
             if (hit?.bundleId && (await bundleExistsMulti(cfg.storageDirs, hit.bundleId))) {
                 return hit.bundleId;
             }
@@ -321,6 +416,33 @@ async function validateBundleCompleteness(bundleRoot) {
         missingComponents,
     };
 }
+/**
+ * Assert that a bundle is complete and ready for operations.
+ * Throws an error with helpful guidance if the bundle is incomplete.
+ * Should be called at the entry point of tools that require a complete bundle
+ * (e.g., dependency graph, trace links, search).
+ */
+export async function assertBundleComplete(cfg, bundleId) {
+    const storageDir = await findBundleStorageDir(cfg.storageDirs, bundleId);
+    if (!storageDir) {
+        throw new Error(`Bundle not found: ${bundleId}`);
+    }
+    const bundleRoot = getBundlePaths(storageDir, bundleId).rootDir;
+    const { isValid, missingComponents } = await validateBundleCompleteness(bundleRoot);
+    if (!isValid) {
+        const issues = missingComponents.join('\n  - ');
+        throw new Error(`Bundle is incomplete and cannot be used for this operation.\n\n` +
+            `Bundle ID: ${bundleId}\n` +
+            `Missing components:\n  - ${issues}\n\n` +
+            `This usually happens when:\n` +
+            `1. Bundle creation was interrupted (timeout, network error, etc.)\n` +
+            `2. Bundle download is still in progress\n\n` +
+            `Suggested actions:\n` +
+            `- Use preflight_update_bundle with force:true to re-download the repository\n` +
+            `- Or use preflight_delete_bundle and preflight_create_bundle to start fresh\n` +
+            `- Check preflight_get_task_status if creation might still be in progress`);
+    }
+}
 /**
  * Detect primary language from ingested files
  */
@@ -624,28 +746,67 @@ async function cloneAndIngestGitHubRepo(params) {
     let repoRootForIngest = tmpCheckoutGit;
     let headSha;
     const notes = [];
+    const warnings = [];
     let source = 'git';
     let fetchedAt = nowIso();
     let refUsed = params.ref;
     try {
-        await shallowClone(cloneUrl, tmpCheckoutGit, { ref: params.ref, timeoutMs: params.cfg.gitCloneTimeoutMs });
+        params.onProgress?.('cloning', 0, `Cloning ${repoId}...`);
+        await shallowClone(cloneUrl, tmpCheckoutGit, {
+            ref: params.ref,
+            timeoutMs: params.cfg.gitCloneTimeoutMs,
+            onProgress: (phase, percent, msg) => {
+                params.onProgress?.('cloning', percent, `${repoId}: ${msg}`);
+            },
+        });
         headSha = await getLocalHeadSha(tmpCheckoutGit);
     }
     catch (err) {
         // Fallback: GitHub archive download (zipball) + extract.
         source = 'archive';
-        const msg = err instanceof Error ? err.message : String(err);
-        notes.push(`git clone failed; used GitHub archive fallback: ${msg}`);
-        const archive = await downloadAndExtractGitHubArchive({
-            cfg: params.cfg,
-            owner: params.owner,
-            repo: params.repo,
-            ref: params.ref,
-            destDir: tmpArchiveDir,
-        });
-        repoRootForIngest = archive.repoRoot;
-        fetchedAt = archive.fetchedAt;
-        refUsed = archive.refUsed;
+        const errMsg = err instanceof Error ? err.message : String(err);
+        notes.push(`git clone failed; used GitHub archive fallback: ${errMsg}`);
+        // User-facing warning: communicate the network issue clearly
+        warnings.push(`⚠️ [${repoId}] Git clone failed (network issue), switched to ZIP download.\n` +
+            `   Reason: ${errMsg.slice(0, 200)}${errMsg.length > 200 ? '...' : ''}`);
+        params.onProgress?.('downloading', 0, `Downloading ${repoId} archive...`);
+        // Track zip path for error message
+        const zipPath = path.join(tmpArchiveDir, `github-zipball-${params.owner}-${params.repo}-partial.zip`);
+        try {
+            const archive = await downloadAndExtractGitHubArchive({
+                cfg: params.cfg,
+                owner: params.owner,
+                repo: params.repo,
+                ref: params.ref,
+                destDir: tmpArchiveDir,
+                onProgress: (downloaded, total, msg) => {
+                    const percent = total ? Math.round((downloaded / total) * 100) : 0;
+                    params.onProgress?.('downloading', percent, `${repoId}: ${msg}`);
+                },
+            });
+            repoRootForIngest = archive.repoRoot;
+            fetchedAt = archive.fetchedAt;
+            refUsed = archive.refUsed;
+            // Success: ZIP download completed
+            warnings.push(`✅ [${repoId}] ZIP download completed successfully as fallback.`);
+        }
+        catch (zipErr) {
+            // ZIP download also failed - provide helpful error with temp path
+            const zipErrMsg = zipErr instanceof Error ? zipErr.message : String(zipErr);
+            // Check if partial file exists
+            const partialExists = await statOrNull(tmpArchiveDir);
+            const tempPathMsg = partialExists
+                ? `\n   Partial files may exist in: ${tmpArchiveDir}`
+                : '';
+            throw new Error(`Both git clone and ZIP download failed for ${repoId}.\n\n` +
+                `Git error: ${errMsg.slice(0, 150)}\n` +
+                `ZIP error: ${zipErrMsg.slice(0, 150)}${tempPathMsg}\n\n` +
+                `Suggestions:\n` +
+                `1. Check your network connection\n` +
+                `2. Verify the repository exists: https://github.com/${repoId}\n` +
+                `3. If you have the repo locally, use 'kind: local' with 'path: /your/local/path'\n` +
+                `4. If behind a proxy, configure GITHUB_TOKEN environment variable`);
+        }
     }
     const bundlePaths = getBundlePaths(params.storageDir, params.bundleId);
     const rawDest = repoRawDir(bundlePaths, params.owner, params.repo);
@@ -679,7 +840,7 @@ async function cloneAndIngestGitHubRepo(params) {
     });
     await rmIfExists(tmpCheckoutGit);
     await rmIfExists(tmpArchiveDir);
-    return { headSha, files: ingested.files, skipped: ingested.skipped, notes, source };
+    return { headSha, files: ingested.files, skipped: ingested.skipped, notes, warnings, source };
 }
 function groupFilesByRepoId(files) {
     const byRepo = new Map();
@@ -721,6 +882,15 @@ export async function createBundle(cfg, input, options) {
 }
 async function createBundleInternal(cfg, input, options) {
     const fingerprint = computeCreateInputFingerprint(input);
+    const repoIds = input.repos.map((r) => r.repo);
+    const onProgress = options?.onProgress;
+    const tracker = getProgressTracker();
+    // Helper to report progress
+    const reportProgress = (phase, progress, message, total) => {
+        if (onProgress) {
+            onProgress(phase, progress, message, total);
+        }
+    };
     const ifExists = options?.ifExists ?? 'error';
     if (ifExists !== 'createNew') {
         const existing = await findExistingBundleByFingerprint(cfg, fingerprint);
@@ -735,6 +905,28 @@ async function createBundleInternal(cfg, input, options) {
             throw new Error(`Bundle already exists for these inputs: ${existing}`);
         }
     }
+    // Start tracking this task
+    const taskId = tracker.startTask(fingerprint, repoIds);
+    reportProgress('starting', 0, `Starting bundle creation for ${repoIds.join(', ')}`);
+    // Try to acquire in-progress lock
+    const lockResult = await setInProgressLock(cfg, fingerprint, taskId, repoIds);
+    if (!lockResult.locked) {
+        // Another task is already creating this bundle
+        const entry = lockResult.existingEntry;
+        const elapsedSec = entry.startedAt
+            ? Math.round((Date.now() - new Date(entry.startedAt).getTime()) / 1000)
+            : 0;
+        const msg = `Bundle creation already in progress (taskId: ${entry.taskId}, started ${elapsedSec}s ago). ` +
+            `Use preflight_get_task_status to check progress.`;
+        // Throw a special error that can be caught and handled
+        const err = new Error(msg);
+        err.code = 'BUNDLE_IN_PROGRESS';
+        err.taskId = entry.taskId;
+        err.fingerprint = fingerprint;
+        err.repos = entry.repos;
+        err.startedAt = entry.startedAt;
+        throw err;
+    }
     const bundleId = crypto.randomUUID();
     const createdAt = nowIso();
     // Use effective storage dir (falls back if primary unavailable)
@@ -747,20 +939,36 @@ async function createBundleInternal(cfg, input, options) {
     const finalPaths = getBundlePaths(effectiveStorageDir, bundleId);
     const allIngestedFiles = [];
     const reposSummary = [];
+    const allWarnings = [];
+    // Track temp checkout directory for cleanup
+    const tmpCheckoutsDir = path.join(cfg.tmpDir, 'checkouts', bundleId);
     try {
         // All operations happen in tmpPaths (temporary directory)
+        const totalRepos = input.repos.length;
+        let repoIndex = 0;
         for (const repoInput of input.repos) {
+            repoIndex++;
+            const repoProgress = Math.round((repoIndex - 1) / totalRepos * 40); // 0-40% for repo fetching
             if (repoInput.kind === 'github') {
                 const { owner, repo } = parseOwnerRepo(repoInput.repo);
-                const { headSha, files, skipped, notes, source } = await cloneAndIngestGitHubRepo({
+                reportProgress('cloning', repoProgress, `[${repoIndex}/${totalRepos}] Fetching ${owner}/${repo}...`);
+                tracker.updateProgress(taskId, 'cloning', repoProgress, `Fetching ${owner}/${repo}...`);
+                const { headSha, files, skipped, notes, warnings, source } = await cloneAndIngestGitHubRepo({
                     cfg,
                     bundleId,
                     storageDir: tmpBundlesDir,
                     owner,
                     repo,
                     ref: repoInput.ref,
+                    onProgress: (phase, percent, msg) => {
+                        // Map clone/download progress to overall progress (0-40% range per repo)
+                        const overallProgress = repoProgress + Math.round(percent * 0.4 / totalRepos);
+                        reportProgress(phase, overallProgress, `[${repoIndex}/${totalRepos}] ${msg}`);
+                        tracker.updateProgress(taskId, phase, overallProgress, msg);
+                    },
                 });
                 allIngestedFiles.push(...files);
+                allWarnings.push(...warnings);
                 reposSummary.push({
                     kind: 'github',
                     id: `${owner}/${repo}`,
@@ -772,6 +980,8 @@ async function createBundleInternal(cfg, input, options) {
             else {
                 // Local repository
                 const { owner, repo } = parseOwnerRepo(repoInput.repo);
+                reportProgress('ingesting', repoProgress, `[${repoIndex}/${totalRepos}] Ingesting local ${owner}/${repo}...`);
+                tracker.updateProgress(taskId, 'ingesting', repoProgress, `Ingesting local ${owner}/${repo}...`);
                 const { files, skipped } = await ingestLocalRepo({
                     cfg,
                     bundleId,
@@ -801,6 +1011,8 @@ async function createBundleInternal(cfg, input, options) {
             librariesSummary = libIngest.libraries;
         }
         // Build index.
+        reportProgress('indexing', 50, `Building search index (${allIngestedFiles.length} files)...`);
+        tracker.updateProgress(taskId, 'indexing', 50, `Building search index (${allIngestedFiles.length} files)...`);
         await rebuildIndex(tmpPaths.searchDbPath, allIngestedFiles, {
             includeDocs: true,
             includeCode: true,
@@ -859,6 +1071,8 @@ async function createBundleInternal(cfg, input, options) {
             libraries: librariesSummary,
         });
         // Generate static facts (FACTS.json) FIRST. This is intentionally non-LLM and safe to keep inside bundles.
+        reportProgress('analyzing', 70, 'Analyzing code structure...');
+        tracker.updateProgress(taskId, 'analyzing', 70, 'Analyzing code structure...');
         await generateFactsBestEffort({
             bundleId,
             bundleRoot: tmpPaths.rootDir,
@@ -866,6 +1080,8 @@ async function createBundleInternal(cfg, input, options) {
             mode: cfg.analysisMode,
         });
         // Overview (S2: factual-only with evidence pointers) - generated AFTER FACTS.json
+        reportProgress('generating', 80, 'Generating overview...');
+        tracker.updateProgress(taskId, 'generating', 80, 'Generating overview...');
         const perRepoOverviews = reposSummary
             .filter((r) => r.kind === 'github' || r.kind === 'local')
             .map((r) => {
@@ -889,6 +1105,8 @@ async function createBundleInternal(cfg, input, options) {
         }
         // ATOMIC OPERATION: Move from temp to final location
         // This is atomic on most filesystems - bundle becomes visible only when complete
+        reportProgress('finalizing', 90, 'Finalizing bundle...');
+        tracker.updateProgress(taskId, 'finalizing', 90, 'Finalizing bundle...');
         logger.info(`Moving bundle ${bundleId} from temp to final location (atomic)`);
         await ensureDir(effectiveStorageDir);
         try {
@@ -915,13 +1133,17 @@ async function createBundleInternal(cfg, input, options) {
             await mirrorBundleToBackups(effectiveStorageDir, cfg.storageDirs, bundleId);
         }
         // Update de-duplication index (best-effort). This is intentionally after atomic move.
-        await updateDedupIndexBestEffort(cfg, fingerprint, bundleId, createdAt);
+        await updateDedupIndexBestEffort(cfg, fingerprint, bundleId, createdAt, 'complete');
+        // Mark task complete
+        reportProgress('complete', 100, `Bundle created: ${bundleId}`);
+        tracker.completeTask(taskId, bundleId);
         const summary = {
             bundleId,
             createdAt,
             updatedAt: createdAt,
             repos: reposSummary,
             libraries: librariesSummary,
+            warnings: allWarnings.length > 0 ? allWarnings : undefined,
         };
         return summary;
     }
@@ -929,8 +1151,15 @@ async function createBundleInternal(cfg, input, options) {
         // Clean up temp directory on failure
         logger.error(`Bundle creation failed, cleaning up temp: ${bundleId}`, err instanceof Error ? err : undefined);
         await rmIfExists(tmpPaths.rootDir);
-        // Enhance error message
+        // Clear in-progress lock on failure
+        await clearInProgressLock(cfg, fingerprint);
+        // Mark task failed
         const errorMsg = err instanceof Error ? err.message : String(err);
+        tracker.failTask(taskId, errorMsg);
+        // Re-throw with enhanced message (unless it's already our BUNDLE_IN_PROGRESS error)
+        if (err?.code === 'BUNDLE_IN_PROGRESS') {
+            throw err;
+        }
         throw new Error(`Failed to create bundle: ${errorMsg}`);
     }
     finally {
@@ -938,6 +1167,10 @@ async function createBundleInternal(cfg, input, options) {
         await rmIfExists(tmpPaths.rootDir).catch((err) => {
             logger.debug('Failed to cleanup temp bundle directory in finally block (non-critical)', err instanceof Error ? err : undefined);
         });
+        // Clean up temp checkouts directory (git clones, zip extracts)
+        await rmIfExists(tmpCheckoutsDir).catch((err) => {
+            logger.debug('Failed to cleanup temp checkouts directory in finally block (non-critical)', err instanceof Error ? err : undefined);
+        });
     }
 }
 /** Check if a bundle has upstream changes without applying updates. */
@@ -1100,6 +1333,14 @@ export async function repairBundle(cfg, bundleId, options) {
     // Manifest is required for safe repairs (no fetching/re-ingest).
     const manifest = await readManifest(paths.manifestPath);
     const actionsTaken = [];
+    const unfixableIssues = [];
+    // Check for unfixable issues (require re-download, can't be repaired offline)
+    const reposHasContent = before.missingComponents.every(c => !c.includes('repos/'));
+    if (!reposHasContent) {
+        unfixableIssues.push('repos/ directory is empty or missing - this requires re-downloading the repository. ' +
+            'Use preflight_delete_bundle and preflight_create_bundle to start fresh, ' +
+            'or use preflight_update_bundle with force:true to re-fetch.');
+    }
     // Determine what needs repair.
     const stAgents = await statOrNull(paths.agentsPath);
     const stStartHere = await statOrNull(paths.startHerePath);
@@ -1187,6 +1428,7 @@ export async function repairBundle(cfg, bundleId, options) {
         mode,
         repaired: actionsTaken.length > 0,
         actionsTaken,
+        unfixableIssues: unfixableIssues.length > 0 ? unfixableIssues : undefined,
         before,
         after,
         updatedAt,
@@ -1198,15 +1440,27 @@ export async function updateBundle(cfg, bundleId, options) {
     const paths = getBundlePaths(effectiveStorageDir, bundleId);
     const manifest = await readManifest(paths.manifestPath);
     const updatedAt = nowIso();
+    const onProgress = options?.onProgress;
+    // Report progress helper
+    const reportProgress = (phase, progress, message, total) => {
+        if (onProgress) {
+            onProgress(phase, progress, message, total);
+        }
+    };
+    reportProgress('starting', 0, `Updating bundle ${bundleId}...`);
     let changed = false;
     const allIngestedFiles = [];
     const reposSummary = [];
+    const totalRepos = manifest.inputs.repos.length;
+    let repoIndex = 0;
     // Rebuild everything obvious for now (simple + deterministic).
     for (const repoInput of manifest.inputs.repos) {
+        repoIndex++;
         if (repoInput.kind === 'github') {
             const { owner, repo } = parseOwnerRepo(repoInput.repo);
             const repoId = `${owner}/${repo}`;
             const cloneUrl = toCloneUrl({ owner, repo });
+            reportProgress('cloning', calcPercent(repoIndex - 1, totalRepos), `Checking ${repoId}...`, totalRepos);
             let remoteSha;
             try {
                 remoteSha = await getRemoteHeadSha(cloneUrl);
@@ -1218,6 +1472,7 @@ export async function updateBundle(cfg, bundleId, options) {
             if (remoteSha && prev?.headSha && remoteSha !== prev.headSha) {
                 changed = true;
             }
+            reportProgress('downloading', calcPercent(repoIndex - 1, totalRepos), `Fetching ${repoId}...`, totalRepos);
             const { headSha, files, skipped, notes, source } = await cloneAndIngestGitHubRepo({
                 cfg,
                 bundleId,
@@ -1225,6 +1480,9 @@ export async function updateBundle(cfg, bundleId, options) {
                 owner,
                 repo,
                 ref: repoInput.ref,
+                onProgress: (phase, progress, message) => {
+                    reportProgress(phase, progress, message);
+                },
             });
             if (prev?.headSha && headSha && headSha !== prev.headSha) {
                 changed = true;
@@ -1257,6 +1515,7 @@ export async function updateBundle(cfg, bundleId, options) {
     // Context7 libraries (best-effort).
     let librariesSummary;
     if (manifest.inputs.libraries?.length) {
+        reportProgress('downloading', 80, 'Fetching Context7 libraries...');
         await rmIfExists(paths.librariesDir);
         await ensureDir(paths.librariesDir);
         const libIngest = await ingestContext7Libraries({
@@ -1269,6 +1528,7 @@ export async function updateBundle(cfg, bundleId, options) {
         librariesSummary = libIngest.libraries;
     }
     // Rebuild index.
+    reportProgress('indexing', 85, `Rebuilding search index (${allIngestedFiles.length} files)...`);
     await rebuildIndex(paths.searchDbPath, allIngestedFiles, {
         includeDocs: manifest.index.includeDocs,
         includeCode: manifest.index.includeCode,
@@ -1294,6 +1554,7 @@ export async function updateBundle(cfg, bundleId, options) {
     };
     await writeManifest(paths.manifestPath, newManifest);
     // Regenerate guides + overview.
+    reportProgress('generating', 90, 'Regenerating guides and overview...');
     await writeAgentsMd(paths.agentsPath);
     await writeStartHereMd({
         targetPath: paths.startHerePath,
@@ -1316,6 +1577,7 @@ export async function updateBundle(cfg, bundleId, options) {
     });
     await writeOverviewFile(paths.overviewPath, overviewMd);
     // Refresh static facts (FACTS.json) after update.
+    reportProgress('analyzing', 95, 'Analyzing bundle...');
     await generateFactsBestEffort({
         bundleId,
         bundleRoot: paths.rootDir,
@@ -1323,11 +1585,13 @@ export async function updateBundle(cfg, bundleId, options) {
         mode: cfg.analysisMode,
     });
     // Mirror to backup storage directories (non-blocking on failures)
+    reportProgress('finalizing', 98, 'Finalizing update...');
     if (cfg.storageDirs.length > 1) {
         await mirrorBundleToBackups(effectiveStorageDir, cfg.storageDirs, bundleId);
     }
     // Keep the de-duplication index fresh (best-effort).
     await updateDedupIndexBestEffort(cfg, fingerprint, bundleId, updatedAt);
+    reportProgress('complete', 100, `Bundle updated: ${bundleId}`);
     const summary = {
         bundleId,
         createdAt: manifest.createdAt,

package/dist/config.js

@@ -88,5 +88,6 @@ export function getConfig() {
         defaultMaxAgeHours: envNumber('PREFLIGHT_DEFAULT_MAX_AGE_HOURS', 24),
         maxSearchLimit: envNumber('PREFLIGHT_MAX_SEARCH_LIMIT', 200),
         defaultSearchLimit: envNumber('PREFLIGHT_DEFAULT_SEARCH_LIMIT', 30),
+        inProgressLockTimeoutMs: envNumber('PREFLIGHT_IN_PROGRESS_LOCK_TIMEOUT_MS', 30 * 60_000),
     };
 }

package/dist/context7/client.js

@@ -20,7 +20,7 @@ export async function connectContext7(cfg) {
             maxRetries: 1,
         },
     });
-    const client = new Client({ name: 'preflight-context7', version: '0.1.3' });
+    const client = new Client({ name: 'preflight-context7', version: '0.1.5' });
     await client.connect(transport);
     return {
         client,