logicstamp-context 0.8.3 → 0.8.5

package/dist/cli/commands/context/watchMode/watchMode.js

@@ -4,7 +4,7 @@
 import { resolve, dirname, join, relative } from 'node:path';
 import { readFile } from 'node:fs/promises';
 import chokidar from 'chokidar';
-import { globFiles } from '../../../../utils/fsx.js';
+import { globFiles, toForwardSlashes } from '../../../../utils/fsx.js';
 import { readStampignore, filterIgnoredFiles } from '../../../../utils/stampignore.js';
 import { buildDependencyGraph } from '../../../../core/manifest.js';
 import { normalizeEntryId } from '../../../../utils/fsx.js';
@@ -69,7 +69,7 @@ export async function startWatchMode(options, projectRoot, initialCache = null)
         }
     }
     let debounceTimer = null;
-    let regenerationPromise = null; // Promise-based lock to prevent race conditions
+    let isRegenerating = false; // Flag-based lock to prevent race conditions
     let changedFiles = new Set();
     /** Snapshot for `getChanges` / strict-watch: set on first load; reset when watch cache is recovered after an error (new stable tree). */
     let baselineBundles = null;
@@ -180,179 +180,193 @@ export async function startWatchMode(options, projectRoot, initialCache = null)
         }
     };
     const regenerate = async () => {
-        // Use Promise-based lock to prevent race conditions
-        // If already regenerating, wait for it to complete then check if more changes came in
-        if (regenerationPromise) {
-            await regenerationPromise;
-            // After waiting, if no new changes accumulated, skip
-            if (changedFiles.size === 0) {
-                return;
-            }
-            // Otherwise, fall through to process new changes
+        // Synchronous flag check - safe in JS single-threaded event loop
+        // If already regenerating, return - the while loop will pick up new changes
+        if (isRegenerating) {
+            return;
         }
-        const changedFileList = Array.from(changedFiles);
-        changedFiles.clear(); // Clear for next batch
-        const startTime = Date.now();
-        // Create a promise for this regeneration cycle (used for lock)
-        const doRegenerate = async () => {
-            try {
-                // Determine output directory
-                const outPath = resolve(options.out);
-                const outputDir = outPath.endsWith('.json') ? dirname(outPath) : outPath;
-                // Load baseline bundles for state-based comparison (like git diff).
-                // Set on first successful load; also updated after error recovery (full rebuild) so diffs stay meaningful.
-                if (!baselineBundles) {
-                    baselineBundles = await loadAllBundles(outputDir);
-                    previousBundles = baselineBundles;
-                }
-                if (!options.quiet) {
-                    const fileList = changedFileList.length > 3
-                        ? `${changedFileList.slice(0, 3).join(', ')}, ... (+${changedFileList.length - 3} more)`
-                        : changedFileList.join(', ');
-                    console.log(`\n🔄 Recompiling (${changedFileList.length} file${changedFileList.length > 1 ? 's' : ''} changed)...`);
-                }
-                let newBundles;
-                // Use incremental rebuild if cache exists, otherwise do full rebuild (fallback)
-                if (watchCache) {
-                    // Incremental rebuild - only rebuild affected bundles
-                    const result = await incrementalRebuild(changedFileList, watchCache, options, projectRoot);
-                    newBundles = result.bundles;
-                    // Write only changed context files
-                    const bundlesByFolder = groupBundlesByFolder(newBundles);
-                    const changedFolders = new Set();
-                    for (const bundleId of result.updatedBundles) {
-                        const bundle = newBundles.find(b => b.entryId === bundleId);
-                        if (bundle) {
-                            const folderPath = bundle.entryId.substring(0, bundle.entryId.lastIndexOf('/') || bundle.entryId.length);
-                            changedFolders.add(folderPath);
-                        }
+        isRegenerating = true;
+        try {
+            // Loop to process any changes that arrive during regeneration
+            while (changedFiles.size > 0) {
+                const changedFileList = Array.from(changedFiles);
+                changedFiles.clear(); // Clear for next batch
+                const startTime = Date.now();
+                try {
+                    // Determine output directory
+                    const outPath = resolve(options.out);
+                    const outputDir = outPath.endsWith('.json') ? dirname(outPath) : outPath;
+                    // Load baseline bundles for state-based comparison (like git diff).
+                    // Set on first successful load; also updated after error recovery (full rebuild) so diffs stay meaningful.
+                    if (!baselineBundles) {
+                        baselineBundles = await loadAllBundles(outputDir);
+                        previousBundles = baselineBundles;
                     }
-                    // Write context files for changed folders only
-                    // (This is a simplified version - full implementation would write individual files)
-                    // For now, we'll write all files but this can be optimized further
-                    const { folderInfos, totalTokenEstimate } = await writeContextFiles(newBundles, outputDir, projectRoot, {
-                        format: options.format,
-                        quiet: true,
-                    });
-                    // Get contracts for main index (from cache if available)
-                    const allContracts = watchCache ? Array.from(watchCache.contracts.values()) : [];
-                    await writeMainIndex(outputDir, folderInfos, allContracts, newBundles, bundlesByFolder.size, totalTokenEstimate, projectRoot, {
-                        quiet: true,
-                        suppressSuccessIndicator: true,
-                    });
-                }
-                else {
-                    // Fallback: Full rebuild if cache not available (shouldn't happen normally)
-                    const regenerateOptions = {
-                        ...options,
-                        watch: false,
-                        strictMissing: false,
-                        quiet: true,
-                        suppressSuccessIndicator: true,
-                    };
-                    await contextCommand(regenerateOptions);
-                    // Load bundles and initialize cache
-                    newBundles = await loadAllBundles(outputDir);
-                    // Initialize cache for next incremental rebuild
-                    if (newBundles.length > 0) {
-                        // We need contracts and manifest - reload them from the build
-                        const files = await globFiles(projectRoot);
-                        const stampignore = await readStampignore(projectRoot);
-                        const filteredFiles = stampignore ? filterIgnoredFiles(files, stampignore.ignore, projectRoot) : files;
-                        const { contracts } = await buildContractsFromFiles(filteredFiles, projectRoot, {
-                            includeStyle: options.includeStyle,
-                            styleMode: options.styleMode,
-                            predictBehavior: options.predictBehavior,
+                    if (!options.quiet) {
+                        const fileList = changedFileList.length > 3
+                            ? `${changedFileList.slice(0, 3).join(', ')}, ... (+${changedFileList.length - 3} more)`
+                            : changedFileList.join(', ');
+                        console.log(`\n🔄 Recompiling (${changedFileList.length} file${changedFileList.length > 1 ? 's' : ''} changed)...`);
+                    }
+                    let newBundles;
+                    // Use incremental rebuild if cache exists, otherwise do full rebuild (fallback)
+                    if (watchCache) {
+                        // Incremental rebuild - only rebuild affected bundles
+                        const result = await incrementalRebuild(changedFileList, watchCache, options, projectRoot);
+                        newBundles = result.bundles;
+                        // Write only changed context files
+                        const bundlesByFolder = groupBundlesByFolder(newBundles);
+                        const changedFolders = new Set();
+                        for (const bundleId of result.updatedBundles) {
+                            const bundle = newBundles.find(b => b.entryId === bundleId);
+                            if (bundle) {
+                                const folderPath = bundle.entryId.substring(0, bundle.entryId.lastIndexOf('/') || bundle.entryId.length);
+                                changedFolders.add(folderPath);
+                            }
+                        }
+                        // Write context files for changed folders only
+                        // (This is a simplified version - full implementation would write individual files)
+                        // For now, we'll write all files but this can be optimized further
+                        const { folderInfos, totalTokenEstimate } = await writeContextFiles(newBundles, outputDir, projectRoot, {
+                            format: options.format,
+                            quiet: true,
+                        });
+                        // Get contracts for main index (from cache if available)
+                        const allContracts = watchCache ? Array.from(watchCache.contracts.values()) : [];
+                        await writeMainIndex(outputDir, folderInfos, allContracts, newBundles, bundlesByFolder.size, totalTokenEstimate, projectRoot, {
                             quiet: true,
+                            suppressSuccessIndicator: true,
                         });
-                        const manifest = buildDependencyGraph(contracts);
-                        watchCache = await initializeWatchCache(filteredFiles, contracts, manifest, newBundles, projectRoot);
                     }
-                }
-                const durationMs = Date.now() - startTime;
-                // Compare against BASELINE (starting state), not previous state
-                // This gives us cumulative diff like `git diff` - if changes are reverted, diff is empty
-                const changes = baselineBundles && baselineBundles.length > 0
-                    ? getChanges(baselineBundles, newBundles)
-                    : null;
-                if (!options.quiet) {
-                    if (changes && (changes.changed.length > 0 || changes.added.length > 0 || changes.removed.length > 0 || changes.bundleChanged.length > 0)) {
-                        showChanges(baselineBundles, newBundles, changedFileList[0] || 'unknown', { debug: options.debug });
+                    else {
+                        // Fallback: Full rebuild if cache not available (shouldn't happen normally)
+                        const regenerateOptions = {
+                            ...options,
+                            watch: false,
+                            strictMissing: false,
+                            quiet: true,
+                            suppressSuccessIndicator: true,
+                        };
+                        await contextCommand(regenerateOptions);
+                        // Load bundles and initialize cache
+                        newBundles = await loadAllBundles(outputDir);
+                        // Initialize cache for next incremental rebuild
+                        if (newBundles.length > 0) {
+                            // We need contracts and manifest - reload them from the build
+                            const files = await globFiles(projectRoot);
+                            const stampignore = await readStampignore(projectRoot);
+                            const filteredFiles = stampignore ? filterIgnoredFiles(files, stampignore.ignore, projectRoot) : files;
+                            const { contracts } = await buildContractsFromFiles(filteredFiles, projectRoot, {
+                                includeStyle: options.includeStyle,
+                                styleMode: options.styleMode,
+                                predictBehavior: options.predictBehavior,
+                                quiet: true,
+                            });
+                            const manifest = buildDependencyGraph(contracts);
+                            watchCache = await initializeWatchCache(filteredFiles, contracts, manifest, newBundles, projectRoot);
+                        }
                     }
-                    console.log(`\n✅ Recompiled\n`);
-                }
-                // Update previousBundles for incremental tracking (still useful for other operations)
-                previousBundles = newBundles;
-                // Strict watch mode: detect and report violations (state-based, like git diff)
-                // Violations are calculated from current state vs baseline, not accumulated
-                if (options.strictWatch && strictWatchStatus) {
-                    const hasChanges = changes && (changes.changed.length > 0 ||
-                        changes.added.length > 0 ||
-                        changes.removed.length > 0 ||
-                        changes.bundleChanged.length > 0);
-                    // Track previous state to detect new violations and resolution
-                    const previousActiveErrors = strictWatchStatus.lastCheck?.errors ?? 0;
-                    const previousActiveWarnings = strictWatchStatus.lastCheck?.warnings ?? 0;
-                    const hadActiveViolations = previousActiveErrors > 0 || previousActiveWarnings > 0;
-                    if (hasChanges) {
-                        const violations = detectViolations({ type: 'watch', changes });
-                        const errors = violations.filter(v => v.severity === 'error');
-                        const warnings = violations.filter(v => v.severity === 'warning');
-                        strictWatchStatus.regenerationCount++;
-                        if (violations.length > 0) {
-                            // Only increment totals if these are NEW violations (first time seeing violations, or count increased)
-                            const isNewViolation = !hadActiveViolations;
-                            const violationCountIncreased = errors.length > previousActiveErrors || warnings.length > previousActiveWarnings;
-                            if (isNewViolation || violationCountIncreased) {
-                                // Calculate new violations (only count increases, not existing ones)
-                                if (isNewViolation) {
-                                    // First time violations appear - count all of them
-                                    strictWatchStatus.totalErrorsDetected += errors.length;
-                                    strictWatchStatus.totalWarningsDetected += warnings.length;
-                                }
-                                else {
-                                    // Violations increased - only count the new ones
-                                    const newErrors = Math.max(0, errors.length - previousActiveErrors);
-                                    const newWarnings = Math.max(0, warnings.length - previousActiveWarnings);
-                                    strictWatchStatus.totalErrorsDetected += newErrors;
-                                    strictWatchStatus.totalWarningsDetected += newWarnings;
+                    const durationMs = Date.now() - startTime;
+                    // Compare against BASELINE (starting state), not previous state
+                    // This gives us cumulative diff like `git diff` - if changes are reverted, diff is empty
+                    const changes = baselineBundles && baselineBundles.length > 0
+                        ? getChanges(baselineBundles, newBundles)
+                        : null;
+                    if (!options.quiet) {
+                        if (changes && (changes.changed.length > 0 || changes.added.length > 0 || changes.removed.length > 0 || changes.bundleChanged.length > 0)) {
+                            showChanges(baselineBundles, newBundles, changedFileList[0] || 'unknown', { debug: options.debug });
+                        }
+                        console.log(`\n✅ Recompiled\n`);
+                    }
+                    // Update previousBundles for incremental tracking (still useful for other operations)
+                    previousBundles = newBundles;
+                    // Strict watch mode: detect and report violations (state-based, like git diff)
+                    // Violations are calculated from current state vs baseline, not accumulated
+                    if (options.strictWatch && strictWatchStatus) {
+                        const hasChanges = changes && (changes.changed.length > 0 ||
+                            changes.added.length > 0 ||
+                            changes.removed.length > 0 ||
+                            changes.bundleChanged.length > 0);
+                        // Track previous state to detect new violations and resolution
+                        const previousActiveErrors = strictWatchStatus.lastCheck?.errors ?? 0;
+                        const previousActiveWarnings = strictWatchStatus.lastCheck?.warnings ?? 0;
+                        const hadActiveViolations = previousActiveErrors > 0 || previousActiveWarnings > 0;
+                        if (hasChanges) {
+                            const violations = detectViolations({ type: 'watch', changes });
+                            const errors = violations.filter(v => v.severity === 'error');
+                            const warnings = violations.filter(v => v.severity === 'warning');
+                            strictWatchStatus.regenerationCount++;
+                            if (violations.length > 0) {
+                                // Only increment totals if these are NEW violations (first time seeing violations, or count increased)
+                                const isNewViolation = !hadActiveViolations;
+                                const violationCountIncreased = errors.length > previousActiveErrors || warnings.length > previousActiveWarnings;
+                                if (isNewViolation || violationCountIncreased) {
+                                    // Calculate new violations (only count increases, not existing ones)
+                                    if (isNewViolation) {
+                                        // First time violations appear - count all of them
+                                        strictWatchStatus.totalErrorsDetected += errors.length;
+                                        strictWatchStatus.totalWarningsDetected += warnings.length;
+                                    }
+                                    else {
+                                        // Violations increased - only count the new ones
+                                        const newErrors = Math.max(0, errors.length - previousActiveErrors);
+                                        const newWarnings = Math.max(0, warnings.length - previousActiveWarnings);
+                                        strictWatchStatus.totalErrorsDetected += newErrors;
+                                        strictWatchStatus.totalWarningsDetected += newWarnings;
+                                    }
                                 }
-                            }
-                            // Update state-based counts (current state, not cumulative)
-                            strictWatchStatus.cumulativeViolations = violations.length;
-                            strictWatchStatus.cumulativeErrors = errors.length;
-                            strictWatchStatus.cumulativeWarnings = warnings.length;
-                            // Store current violations
-                            strictWatchStatus.lastCheck = {
-                                timestamp: new Date().toISOString(),
-                                totalViolations: violations.length,
-                                errors: errors.length,
-                                warnings: warnings.length,
-                                violations,
-                                changedFiles: changedFileList,
-                            };
-                            // Display violations to console (only if status changed)
-                            if (!options.quiet) {
-                                const statusChanged = errors.length !== previousActiveErrors || warnings.length !== previousActiveWarnings;
-                                if (statusChanged) {
-                                    if (isNewViolation || violationCountIncreased) {
-                                        // Show appropriate emoji based on severity: ❌ for errors, ⚠️ for warnings only
-                                        if (errors.length > 0) {
-                                            console.log(`\n❌ Breaking change detected`);
-                                        }
-                                        else if (warnings.length > 0) {
-                                            console.log(`\n⚠️  Warning detected`);
+                                // Update state-based counts (current state, not cumulative)
+                                strictWatchStatus.cumulativeViolations = violations.length;
+                                strictWatchStatus.cumulativeErrors = errors.length;
+                                strictWatchStatus.cumulativeWarnings = warnings.length;
+                                // Store current violations
+                                strictWatchStatus.lastCheck = {
+                                    timestamp: new Date().toISOString(),
+                                    totalViolations: violations.length,
+                                    errors: errors.length,
+                                    warnings: warnings.length,
+                                    violations,
+                                    changedFiles: changedFileList,
+                                };
+                                // Display violations to console (only if status changed)
+                                if (!options.quiet) {
+                                    const statusChanged = errors.length !== previousActiveErrors || warnings.length !== previousActiveWarnings;
+                                    if (statusChanged) {
+                                        if (isNewViolation || violationCountIncreased) {
+                                            // Show appropriate emoji based on severity: ❌ for errors, ⚠️ for warnings only
+                                            if (errors.length > 0) {
+                                                console.log(`\n❌ Breaking change detected`);
+                                            }
+                                            else if (warnings.length > 0) {
+                                                console.log(`\n⚠️  Warning detected`);
+                                            }
                                         }
+                                        displayViolations(violations, { quiet: options.quiet });
+                                        displaySessionStatus(strictWatchStatus, { quiet: options.quiet });
                                     }
-                                    displayViolations(violations, { quiet: options.quiet });
+                                }
+                                // Write current violations state to disk
+                                await writeStrictWatchStatus(projectRoot, strictWatchStatus);
+                            }
+                            else {
+                                // Changes exist but no violations - violations were resolved
+                                if (hadActiveViolations) {
+                                    strictWatchStatus.resolvedCount++;
+                                }
+                                strictWatchStatus.cumulativeViolations = 0;
+                                strictWatchStatus.cumulativeErrors = 0;
+                                strictWatchStatus.cumulativeWarnings = 0;
+                                strictWatchStatus.lastCheck = undefined;
+                                // Display resolution message and status
+                                if (!options.quiet && hadActiveViolations) {
+                                    console.log(`\n✅ Violation resolved`);
                                     displaySessionStatus(strictWatchStatus, { quiet: options.quiet });
                                 }
+                                await deleteStrictWatchStatus(projectRoot);
                             }
-                            // Write current violations state to disk
-                            await writeStrictWatchStatus(projectRoot, strictWatchStatus);
                         }
                         else {
-                            // Changes exist but no violations - violations were resolved
+                            // No changes from baseline - clear violations (state reverted)
                             if (hadActiveViolations) {
                                 strictWatchStatus.resolvedCount++;
                             }
@@ -368,111 +382,93 @@ export async function startWatchMode(options, projectRoot, initialCache = null)
                             await deleteStrictWatchStatus(projectRoot);
                         }
                     }
-                    else {
-                        // No changes from baseline - clear violations (state reverted)
-                        if (hadActiveViolations) {
-                            strictWatchStatus.resolvedCount++;
+                    // Log structured data for MCP server (only if --log-file flag is set)
+                    // Appends each event to the log file for event history
+                    if (options.logFile) {
+                        if (changes) {
+                            const logEntry = {
+                                timestamp: new Date().toISOString(),
+                                changedFiles: changedFileList,
+                                fileCount: changedFileList.length,
+                                durationMs,
+                                modifiedContracts: changes.changed.map(c => ({
+                                    entryId: c.entryId,
+                                    semanticHashChanged: !!c.semanticHash,
+                                    fileHashChanged: !!c.fileHash,
+                                    semanticHash: c.semanticHash,
+                                    fileHash: c.fileHash,
+                                })),
+                                modifiedBundles: changes.bundleChanged.map(b => ({
+                                    entryId: b.entryId,
+                                    bundleHash: { old: b.oldHash, new: b.newHash },
+                                })),
+                                addedContracts: changes.added.length > 0 ? changes.added : undefined,
+                                removedContracts: changes.removed.length > 0 ? changes.removed : undefined,
+                                summary: {
+                                    modifiedContractsCount: changes.changed.length,
+                                    modifiedBundlesCount: changes.bundleChanged.length,
+                                    addedContractsCount: changes.added.length,
+                                    removedContractsCount: changes.removed.length,
+                                },
+                            };
+                            await appendWatchLog(projectRoot, logEntry);
                         }
-                        strictWatchStatus.cumulativeViolations = 0;
-                        strictWatchStatus.cumulativeErrors = 0;
-                        strictWatchStatus.cumulativeWarnings = 0;
-                        strictWatchStatus.lastCheck = undefined;
-                        // Display resolution message and status
-                        if (!options.quiet && hadActiveViolations) {
-                            console.log(`\n✅ Violation resolved`);
-                            displaySessionStatus(strictWatchStatus, { quiet: options.quiet });
+                        else if (changedFileList.length > 0) {
+                            // Log even if no changes detected (file changed but no contract changes)
+                            const logEntry = {
+                                timestamp: new Date().toISOString(),
+                                changedFiles: changedFileList,
+                                fileCount: changedFileList.length,
+                                durationMs,
+                            };
+                            await appendWatchLog(projectRoot, logEntry);
                         }
-                        await deleteStrictWatchStatus(projectRoot);
                     }
                 }
-                // Log structured data for MCP server (only if --log-file flag is set)
-                // Appends each event to the log file for event history
-                if (options.logFile) {
-                    if (changes) {
-                        const logEntry = {
-                            timestamp: new Date().toISOString(),
-                            changedFiles: changedFileList,
-                            fileCount: changedFileList.length,
-                            durationMs,
-                            modifiedContracts: changes.changed.map(c => ({
-                                entryId: c.entryId,
-                                semanticHashChanged: !!c.semanticHash,
-                                fileHashChanged: !!c.fileHash,
-                                semanticHash: c.semanticHash,
-                                fileHash: c.fileHash,
-                            })),
-                            modifiedBundles: changes.bundleChanged.map(b => ({
-                                entryId: b.entryId,
-                                bundleHash: { old: b.oldHash, new: b.newHash },
-                            })),
-                            addedContracts: changes.added.length > 0 ? changes.added : undefined,
-                            removedContracts: changes.removed.length > 0 ? changes.removed : undefined,
-                            summary: {
-                                modifiedContractsCount: changes.changed.length,
-                                modifiedBundlesCount: changes.bundleChanged.length,
-                                addedContractsCount: changes.added.length,
-                                removedContractsCount: changes.removed.length,
-                            },
-                        };
-                        await appendWatchLog(projectRoot, logEntry);
-                    }
-                    else if (changedFileList.length > 0) {
-                        // Log even if no changes detected (file changed but no contract changes)
-                        const logEntry = {
-                            timestamp: new Date().toISOString(),
-                            changedFiles: changedFileList,
-                            fileCount: changedFileList.length,
-                            durationMs,
-                        };
-                        await appendWatchLog(projectRoot, logEntry);
+                catch (error) {
+                    const durationMs = Date.now() - startTime;
+                    const errorMessage = formatErrorMessage(error);
+                    if (!options.quiet) {
+                        console.error(`   ❌ Error: ${errorMessage}\n`);
                     }
-                }
-            }
-            catch (error) {
-                const durationMs = Date.now() - startTime;
-                const errorMessage = formatErrorMessage(error);
-                if (!options.quiet) {
-                    console.error(`   ❌ Error: ${errorMessage}\n`);
-                }
-                if (options.logFile) {
-                    try {
-                        const logEntry = {
-                            timestamp: new Date().toISOString(),
-                            changedFiles: changedFileList,
-                            fileCount: changedFileList.length,
-                            durationMs,
-                            error: errorMessage,
-                        };
-                        await appendWatchLog(projectRoot, logEntry);
+                    if (options.logFile) {
+                        try {
+                            const logEntry = {
+                                timestamp: new Date().toISOString(),
+                                changedFiles: changedFileList,
+                                fileCount: changedFileList.length,
+                                durationMs,
+                                error: errorMessage,
+                            };
+                            await appendWatchLog(projectRoot, logEntry);
+                        }
+                        catch (logError) {
+                            if (!options.quiet) {
+                                console.warn(`   ⚠️  Watch: could not append watch log: ${formatErrorMessage(logError)}`);
+                            }
+                        }
                     }
-                    catch (logError) {
+                    const recovery = await attemptWatchCacheRecovery();
+                    if (recovery != null) {
+                        watchCache = recovery.cache;
+                        baselineBundles = recovery.bundles;
+                        previousBundles = recovery.bundles;
                         if (!options.quiet) {
-                            console.warn(`   ⚠️  Watch: could not append watch log: ${formatErrorMessage(logError)}`);
+                            console.log(`   ✅ Watch cache restored after full rebuild.\n`);
                         }
                     }
-                }
-                const recovery = await attemptWatchCacheRecovery();
-                if (recovery != null) {
-                    watchCache = recovery.cache;
-                    baselineBundles = recovery.bundles;
-                    previousBundles = recovery.bundles;
-                    if (!options.quiet) {
-                        console.log(`   ✅ Watch cache restored after full rebuild.\n`);
-                    }
-                }
-                else {
-                    watchCache = null;
-                    if (!options.quiet) {
-                        console.warn('   ⚠️  Each file change will run a full context rebuild until a rebuild succeeds.\n');
+                    else {
+                        watchCache = null;
+                        if (!options.quiet) {
+                            console.warn('   ⚠️  Each file change will run a full context rebuild until a rebuild succeeds.\n');
+                        }
                     }
                 }
             }
-        };
-        // Execute and track the regeneration promise
-        regenerationPromise = doRegenerate().finally(() => {
-            regenerationPromise = null;
-        });
-        await regenerationPromise;
+        }
+        finally {
+            isRegenerating = false;
+        }
     };
     const debouncedRegenerate = () => {
         if (debounceTimer) {
@@ -512,7 +508,7 @@ export async function startWatchMode(options, projectRoot, initialCache = null)
                 /context_main\.json$/,
                 /context_compare_modes\.json$/,
                 // Ignore output directory if different from project root
-                ...(outputDir !== projectRoot ? [new RegExp('^' + relative(projectRoot, normalizedOutputDir).replace(/\\/g, '/'))] : []),
+                ...(outputDir !== projectRoot ? [new RegExp('^' + toForwardSlashes(relative(projectRoot, normalizedOutputDir)))] : []),
                 // Ignore common build/dependency directories
                 /node_modules/,
                 /dist/,
@@ -531,7 +527,7 @@ export async function startWatchMode(options, projectRoot, initialCache = null)
         // Helper to check if a file should trigger regeneration
         const shouldTrigger = (filePath) => {
             // Normalize path separators
-            const normalizedPath = filePath.replace(/\\/g, '/');
+            const normalizedPath = toForwardSlashes(filePath);
             // Debug logging (can be enabled with LOGICSTAMP_DEBUG=1)
             if (process.env.LOGICSTAMP_DEBUG === '1' && !options.quiet) {
                 console.log(`[DEBUG] Watch event for: ${normalizedPath}`);