grepmind-core 0.1.0-alpha

package/dist/indexer/wal/sync-wal.js

@@ -0,0 +1,863 @@
+/**
+ * SyncWal - Unified Write-Ahead Log for Sync Tasks
+ *
+ * PostgreSQL-inspired WAL with:
+ * - LSN (Log Sequence Number) for recovery positioning
+ * - Checkpoint + truncate for bounded WAL size
+ * - Offset-based recovery (no paths stored)
+ * - Global lock with heartbeat for stale detection
+ * - Cancellation support
+ */
+import { randomUUID } from 'node:crypto';
+import { FileWalStorage } from './file-storage.js';
+import { DEFAULT_SYNC_WAL_CONFIG } from './types.js';
+// ═══════════════════════════════════════════════════════════════════════════
+// SYNC WAL CLASS
+// ═══════════════════════════════════════════════════════════════════════════
+export class SyncWal {
+    storage;
+    config;
+    // Current state
+    currentLsn = 0;
+    currentTaskId = null;
+    currentTaskType = null;
+    totalFiles = 0;
+    manifestHash = null;
+    startedAt = 0;
+    phase = 'analyzing';
+    currentFile = null;
+    // Memtable (in-memory state between checkpoints)
+    memtable = null;
+    // Checkpoint tracking
+    filesSinceCheckpoint = 0;
+    checkpointProcessedCount = 0;
+    lastCheckpointLsn = 0;
+    // Heartbeat
+    heartbeatInterval;
+    // Cancellation and pause
+    cancelRequested = new Set();
+    pauseRequested = new Set();
+    isPaused = false;
+    // Event callback
+    onProgressCallback;
+    onEmbeddingProgressCallback;
+    onSubPhaseProgressCallback;
+    constructor(storage, config) {
+        this.storage = storage;
+        this.config = { ...DEFAULT_SYNC_WAL_CONFIG, ...config };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // INITIALIZATION
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Initialize SyncWal - call on server start
+     * Handles stale lock detection and recovery
+     */
+    async initialize() {
+        // Check for stale locks
+        const lockStatus = await this.isLocked();
+        if (lockStatus.locked && lockStatus.stale && lockStatus.lock) {
+            console.warn('Detected stale lock, clearing...');
+            await this.forceClearStaleLock();
+        }
+        // Load manifest to restore LSN
+        const manifest = await this.storage.getManifest();
+        if (manifest) {
+            this.currentLsn = manifest.walLsn;
+            this.lastCheckpointLsn = manifest.lastCheckpointLsn;
+        }
+        // Check for recovery
+        return this.recover();
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // WRITE PATH (hot path — optimized for speed)
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Start a new sync task
+     */
+    async startTask(type, totalFiles, manifestHash) {
+        const taskId = randomUUID();
+        const now = Date.now();
+        // Acquire lock
+        const lock = {
+            id: taskId,
+            type,
+            pid: process.pid,
+            startedAt: now,
+            heartbeat: now,
+        };
+        const acquired = await this.acquireLock(lock);
+        if (!acquired) {
+            throw new Error(`Cannot start ${type} sync: another sync is already running`);
+        }
+        try {
+            // Initialize state
+            this.currentTaskId = taskId;
+            this.currentTaskType = type;
+            this.totalFiles = totalFiles;
+            this.manifestHash = manifestHash || null;
+            this.startedAt = now;
+            this.phase = 'indexing';
+            this.currentFile = null;
+            this.filesSinceCheckpoint = 0;
+            this.checkpointProcessedCount = 0;
+            // Initialize memtable
+            this.memtable = {
+                taskId,
+                processedCount: 0,
+                failedPaths: new Map(),
+                stats: { added: 0, updated: 0, deleted: 0 },
+                lastLsn: this.currentLsn,
+            };
+            // Append task:start to WAL
+            const entry = {
+                lsn: this.currentLsn++,
+                ts: now,
+                op: 'task:start',
+                taskId,
+                data: {
+                    type,
+                    totalFiles,
+                    manifestHash,
+                },
+            };
+            await this.storage.appendEntry(entry);
+            // Create/update manifest
+            const task = {
+                id: taskId,
+                type,
+                status: 'running',
+                startedAt: now,
+                updatedAt: now,
+                phase: 'indexing',
+                totalFiles,
+                processedFiles: 0,
+                added: 0,
+                updated: 0,
+                deleted: 0,
+                failedFiles: [],
+                manifestHash,
+                lastCheckpointLsn: this.lastCheckpointLsn,
+            };
+            const manifest = {
+                version: 1,
+                current: task,
+                lastCompleted: (await this.storage.getManifest())?.lastCompleted || null,
+                walLsn: this.currentLsn,
+                lastCheckpointLsn: this.lastCheckpointLsn,
+            };
+            await this.storage.writeManifest(manifest);
+            // Start heartbeat
+            this.startHeartbeat();
+            // Emit progress
+            this.emitProgress();
+            return taskId;
+        }
+        catch (err) {
+            // Release lock on any error after acquisition
+            await this.storage.releaseLock(taskId);
+            this.currentTaskId = null;
+            this.currentTaskType = null;
+            this.memtable = null;
+            throw err;
+        }
+    }
+    /**
+     * Mark a file as successfully processed
+     */
+    async fileProcessed(taskId, path, chunks, action = 'updated') {
+        if (taskId !== this.currentTaskId || !this.memtable) {
+            throw new Error('Task not active');
+        }
+        // Update current file
+        this.currentFile = path;
+        // 1. Append to WAL (O(1) write)
+        await this.storage.appendEntry({
+            lsn: this.currentLsn++,
+            ts: Date.now(),
+            op: 'file:done',
+            taskId,
+            data: { path, chunks },
+        });
+        // 2. Update memtable (O(1))
+        this.memtable.processedCount++;
+        this.memtable.lastLsn = this.currentLsn;
+        if (action === 'added') {
+            this.memtable.stats.added++;
+        }
+        else {
+            this.memtable.stats.updated++;
+        }
+        this.filesSinceCheckpoint++;
+        // 3. Maybe checkpoint (amortized O(1))
+        if (this.filesSinceCheckpoint >= this.config.checkpointInterval) {
+            await this.checkpoint();
+        }
+        // 4. Emit progress (every 10 files or on checkpoint)
+        if (this.filesSinceCheckpoint % 10 === 0) {
+            this.emitProgress();
+        }
+    }
+    /**
+     * Mark a file as failed
+     */
+    async fileFailed(taskId, path, error, retries) {
+        if (taskId !== this.currentTaskId || !this.memtable) {
+            throw new Error('Task not active');
+        }
+        // Append to WAL
+        await this.storage.appendEntry({
+            lsn: this.currentLsn++,
+            ts: Date.now(),
+            op: 'file:fail',
+            taskId,
+            data: { path, error, retries },
+        });
+        // Update memtable
+        this.memtable.failedPaths.set(path, { error, retries });
+        this.memtable.processedCount++;
+        this.memtable.lastLsn = this.currentLsn;
+        this.filesSinceCheckpoint++;
+        // Maybe checkpoint
+        if (this.filesSinceCheckpoint >= this.config.checkpointInterval) {
+            await this.checkpoint();
+        }
+    }
+    /**
+     * Mark file as deleted
+     */
+    async fileDeleted(taskId, path) {
+        if (taskId !== this.currentTaskId || !this.memtable) {
+            throw new Error('Task not active');
+        }
+        // Append to WAL
+        await this.storage.appendEntry({
+            lsn: this.currentLsn++,
+            ts: Date.now(),
+            op: 'file:done',
+            taskId,
+            data: { path, chunks: 0 },
+        });
+        // Update memtable
+        this.memtable.stats.deleted++;
+        this.memtable.processedCount++;
+        this.memtable.lastLsn = this.currentLsn;
+        this.filesSinceCheckpoint++;
+        // Maybe checkpoint
+        if (this.filesSinceCheckpoint >= this.config.checkpointInterval) {
+            await this.checkpoint();
+        }
+    }
+    /**
+     * Complete the sync task
+     */
+    async completeTask(taskId) {
+        console.log(`[SyncWal.completeTask] completing task ${taskId}`);
+        if (taskId !== this.currentTaskId || !this.memtable) {
+            throw new Error('Task not active');
+        }
+        const now = Date.now();
+        // Get cumulative stats
+        const stats = this.getCumulativeStats();
+        // Append task:complete to WAL
+        await this.storage.appendEntry({
+            lsn: this.currentLsn++,
+            ts: now,
+            op: 'task:complete',
+            taskId,
+            data: { stats },
+        });
+        // Update manifest
+        const summary = {
+            id: taskId,
+            type: this.currentTaskType,
+            status: 'completed',
+            startedAt: this.startedAt,
+            completedAt: now,
+            totalFiles: this.totalFiles,
+            stats: {
+                added: stats.added,
+                updated: stats.updated,
+                deleted: stats.deleted,
+            },
+            failedCount: stats.failed.length,
+        };
+        const manifest = {
+            version: 1,
+            current: null,
+            lastCompleted: summary,
+            walLsn: this.currentLsn,
+            lastCheckpointLsn: this.lastCheckpointLsn,
+        };
+        await this.storage.writeManifest(manifest);
+        // Clear checkpoint (task is done)
+        await this.storage.writeCheckpoint({
+            version: 1,
+            lsn: this.currentLsn,
+            createdAt: now,
+            task: {
+                id: taskId,
+                type: this.currentTaskType,
+                status: 'completed',
+                startedAt: this.startedAt,
+                totalFiles: this.totalFiles,
+                processedCount: this.checkpointProcessedCount + this.memtable.processedCount,
+                manifestHash: this.manifestHash || undefined,
+            },
+            stats,
+        });
+        console.log(`[SyncWal.completeTask] checkpoint written with status=completed for task ${taskId}`);
+        // Update phase for final progress emit
+        this.phase = 'done';
+        this.emitProgress();
+        // Cleanup
+        await this.cleanup();
+    }
+    /**
+     * Fail the sync task
+     */
+    async failTask(taskId, error) {
+        if (taskId !== this.currentTaskId) {
+            throw new Error('Task not active');
+        }
+        const now = Date.now();
+        const stats = this.getCumulativeStats();
+        // Append task:fail to WAL
+        await this.storage.appendEntry({
+            lsn: this.currentLsn++,
+            ts: now,
+            op: 'task:fail',
+            taskId,
+            data: { stats, error },
+        });
+        // Update manifest
+        const summary = {
+            id: taskId,
+            type: this.currentTaskType,
+            status: 'failed',
+            startedAt: this.startedAt,
+            completedAt: now,
+            totalFiles: this.totalFiles,
+            stats: {
+                added: stats.added,
+                updated: stats.updated,
+                deleted: stats.deleted,
+            },
+            failedCount: stats.failed.length,
+        };
+        const manifest = {
+            version: 1,
+            current: null,
+            lastCompleted: summary,
+            walLsn: this.currentLsn,
+            lastCheckpointLsn: this.lastCheckpointLsn,
+        };
+        await this.storage.writeManifest(manifest);
+        // Cleanup
+        await this.cleanup();
+    }
+    /**
+     * Cancel the sync task
+     */
+    async cancelTask(taskId) {
+        if (taskId !== this.currentTaskId) {
+            throw new Error('Task not active');
+        }
+        const now = Date.now();
+        const stats = this.getCumulativeStats();
+        // Append task:cancel to WAL
+        await this.storage.appendEntry({
+            lsn: this.currentLsn++,
+            ts: now,
+            op: 'task:cancel',
+            taskId,
+        });
+        // Update manifest
+        const summary = {
+            id: taskId,
+            type: this.currentTaskType,
+            status: 'cancelled',
+            startedAt: this.startedAt,
+            completedAt: now,
+            totalFiles: this.totalFiles,
+            stats: {
+                added: stats.added,
+                updated: stats.updated,
+                deleted: stats.deleted,
+            },
+            failedCount: stats.failed.length,
+        };
+        const manifest = {
+            version: 1,
+            current: null,
+            lastCompleted: summary,
+            walLsn: this.currentLsn,
+            lastCheckpointLsn: this.lastCheckpointLsn,
+        };
+        await this.storage.writeManifest(manifest);
+        // Cleanup
+        await this.cleanup();
+    }
+    /**
+     * Set task phase
+     */
+    setPhase(phase) {
+        this.phase = phase;
+        this.emitProgress();
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CHECKPOINT (PostgreSQL-style)
+    // ═══════════════════════════════════════════════════════════════════════════
+    async checkpoint() {
+        if (!this.memtable || !this.currentTaskId)
+            return;
+        const checkpointLsn = this.currentLsn;
+        const totalProcessed = this.checkpointProcessedCount + this.memtable.processedCount;
+        const now = Date.now();
+        // 1. Write checkpoint marker to WAL
+        await this.storage.appendEntry({
+            lsn: checkpointLsn,
+            ts: now,
+            op: 'checkpoint',
+            taskId: this.currentTaskId,
+            data: { processedCount: totalProcessed },
+        });
+        this.currentLsn++;
+        // 2. Get cumulative stats
+        const stats = this.getCumulativeStats();
+        // 3. Write checkpoint file
+        await this.storage.writeCheckpoint({
+            version: 1,
+            lsn: checkpointLsn,
+            createdAt: now,
+            task: {
+                id: this.currentTaskId,
+                type: this.currentTaskType,
+                status: 'running',
+                startedAt: this.startedAt,
+                totalFiles: this.totalFiles,
+                processedCount: totalProcessed,
+                manifestHash: this.manifestHash || undefined,
+            },
+            stats,
+        });
+        // 4. Truncate WAL before checkpoint LSN
+        await this.storage.truncateBeforeLsn(checkpointLsn);
+        // 5. Update manifest
+        const manifest = await this.storage.getManifest();
+        if (manifest) {
+            manifest.lastCheckpointLsn = checkpointLsn;
+            manifest.walLsn = this.currentLsn;
+            if (manifest.current) {
+                manifest.current.processedFiles = totalProcessed;
+                manifest.current.updatedAt = now;
+                manifest.current.lastCheckpointLsn = checkpointLsn;
+            }
+            await this.storage.writeManifest(manifest);
+        }
+        // 6. Update checkpoint baseline and clear memtable counts
+        this.checkpointProcessedCount = totalProcessed;
+        this.lastCheckpointLsn = checkpointLsn;
+        this.memtable.processedCount = 0;
+        this.filesSinceCheckpoint = 0;
+        // 7. Update heartbeat
+        await this.storage.updateHeartbeat(this.currentTaskId);
+        // 8. Emit progress
+        this.emitProgress();
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // RECOVERY (checkpoint + WAL replay)
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Check for incomplete task and return recovery plan
+     */
+    async recover() {
+        // 1. Load checkpoint (O(1), small file ~1KB)
+        const checkpoint = await this.storage.getCheckpoint();
+        // Debug logging
+        if (checkpoint) {
+            console.log(`[SyncWal.recover] checkpoint found: taskId=${checkpoint.task.id}, status=${checkpoint.task.status}, type=${checkpoint.task.type}`);
+        }
+        else {
+            console.log('[SyncWal.recover] no checkpoint found');
+        }
+        if (!checkpoint || checkpoint.task.status !== 'running') {
+            return null;
+        }
+        // 2. Read WAL tail (only entries after last checkpoint)
+        const walEntries = await this.storage.getEntriesFromLsn(checkpoint.lsn);
+        // 3. Count file:done entries in WAL tail
+        let walProcessedCount = 0;
+        for (const entry of walEntries) {
+            if (entry.op === 'file:done') {
+                walProcessedCount++;
+            }
+            // Update LSN from WAL
+            if (entry.lsn >= this.currentLsn) {
+                this.currentLsn = entry.lsn + 1;
+            }
+        }
+        // 4. Total skip count = checkpoint.processedCount + WAL tail count
+        const skipCount = checkpoint.task.processedCount + walProcessedCount;
+        // 5. Return recovery plan
+        return {
+            taskId: checkpoint.task.id,
+            type: checkpoint.task.type,
+            totalFiles: checkpoint.task.totalFiles,
+            skipCount,
+            manifestHash: checkpoint.task.manifestHash || '',
+            stats: checkpoint.stats,
+        };
+    }
+    /**
+     * Resume a task from recovery plan
+     */
+    async resumeTask(plan) {
+        const now = Date.now();
+        // Restore state from recovery plan
+        this.currentTaskId = plan.taskId;
+        this.currentTaskType = plan.type;
+        this.totalFiles = plan.totalFiles;
+        this.manifestHash = plan.manifestHash || null;
+        this.checkpointProcessedCount = plan.skipCount;
+        this.phase = 'indexing';
+        // Re-acquire lock
+        const lock = {
+            id: plan.taskId,
+            type: plan.type,
+            pid: process.pid,
+            startedAt: now,
+            heartbeat: now,
+        };
+        // Force acquire (we know there's no valid lock from recovery check)
+        if (this.storage instanceof FileWalStorage) {
+            await this.storage.forceClearLock();
+        }
+        const acquired = await this.storage.acquireLock(lock);
+        if (!acquired) {
+            throw new Error('Failed to re-acquire lock for recovery');
+        }
+        // Initialize memtable with restored stats
+        this.memtable = {
+            taskId: plan.taskId,
+            processedCount: 0,
+            failedPaths: new Map(plan.stats.failed.map((f) => [f.path, { error: f.error, retries: f.retries }])),
+            stats: {
+                added: plan.stats.added,
+                updated: plan.stats.updated,
+                deleted: plan.stats.deleted,
+            },
+            lastLsn: this.currentLsn,
+        };
+        // Update manifest
+        const manifest = await this.storage.getManifest();
+        if (manifest && manifest.current) {
+            manifest.current.updatedAt = now;
+            await this.storage.writeManifest(manifest);
+        }
+        // Start heartbeat
+        this.startHeartbeat();
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // STATE QUERIES
+    // ═══════════════════════════════════════════════════════════════════════════
+    async getManifest() {
+        return this.storage.getManifest();
+    }
+    async getCurrentTask() {
+        const manifest = await this.storage.getManifest();
+        return manifest?.current || null;
+    }
+    async getLastCompleted() {
+        const manifest = await this.storage.getManifest();
+        return manifest?.lastCompleted || null;
+    }
+    getProgress() {
+        if (!this.currentTaskId || !this.currentTaskType) {
+            return null;
+        }
+        const stats = this.getCumulativeStats();
+        const processedFiles = this.checkpointProcessedCount + (this.memtable?.processedCount || 0);
+        const now = Date.now();
+        const elapsedMs = now - this.startedAt;
+        // Estimate remaining time
+        let estimatedRemainingMs;
+        if (processedFiles > 0) {
+            const msPerFile = elapsedMs / processedFiles;
+            const remainingFiles = this.totalFiles - processedFiles;
+            estimatedRemainingMs = Math.round(msPerFile * remainingFiles);
+        }
+        return {
+            taskId: this.currentTaskId,
+            type: this.currentTaskType,
+            status: this.isPaused ? 'paused' : 'running',
+            phase: this.phase,
+            paused: this.isPaused,
+            totalFiles: this.totalFiles,
+            processedFiles,
+            currentFile: this.currentFile || undefined,
+            added: stats.added,
+            updated: stats.updated,
+            deleted: stats.deleted,
+            failedCount: stats.failed.length,
+            startedAt: this.startedAt,
+            elapsedMs,
+            estimatedRemainingMs,
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // LOCK MANAGEMENT
+    // ═══════════════════════════════════════════════════════════════════════════
+    async acquireLock(lock) {
+        // First try to acquire directly
+        const acquired = await this.storage.acquireLock(lock);
+        if (acquired)
+            return true;
+        // Check if existing lock is stale
+        const status = await this.isLocked();
+        if (status.locked && status.stale && status.lock) {
+            // Atomic compare-and-clear: only clear if lock unchanged
+            if (this.storage instanceof FileWalStorage) {
+                const cleared = await this.storage.compareAndClearLock(status.lock);
+                if (cleared) {
+                    // Retry acquire
+                    return this.storage.acquireLock(lock);
+                }
+            }
+        }
+        return false;
+    }
+    async releaseLock() {
+        if (this.currentTaskId) {
+            await this.storage.releaseLock(this.currentTaskId);
+        }
+    }
+    async isLocked() {
+        const lock = await this.storage.getLock();
+        if (!lock) {
+            return { locked: false, stale: false };
+        }
+        // Check if stale
+        const now = Date.now();
+        const heartbeatAge = now - lock.heartbeat;
+        const isHeartbeatStale = heartbeatAge > this.config.staleLockTimeout;
+        const isPidDead = !FileWalStorage.isPidRunning(lock.pid);
+        const stale = isHeartbeatStale || isPidDead;
+        return { locked: true, stale, lock };
+    }
+    async forceClearStaleLock() {
+        const status = await this.isLocked();
+        if (!status.locked) {
+            return true; // No lock to clear
+        }
+        if (!status.stale) {
+            return false; // Lock is not stale, cannot force clear
+        }
+        if (this.storage instanceof FileWalStorage) {
+            await this.storage.forceClearLock();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Clear all WAL state (lock, checkpoint, WAL entries, manifest).
+     * Use this to reset sync state when stuck in recovery loop.
+     * WARNING: This will lose any recovery information for incomplete syncs.
+     */
+    async clear() {
+        // Stop any running task first
+        this.stopHeartbeat();
+        await this.releaseLock();
+        // Clear all storage
+        await this.storage.clear();
+        // Reset in-memory state
+        this.currentTaskId = null;
+        this.currentTaskType = null;
+        this.memtable = null;
+        this.totalFiles = 0;
+        this.manifestHash = null;
+        this.filesSinceCheckpoint = 0;
+        this.checkpointProcessedCount = 0;
+        this.currentFile = null;
+        this.phase = 'analyzing';
+        this.currentLsn = 0;
+        this.lastCheckpointLsn = 0;
+        this.startedAt = 0;
+        this.cancelRequested.clear();
+        this.pauseRequested.clear();
+        this.isPaused = false;
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // HEARTBEAT
+    // ═══════════════════════════════════════════════════════════════════════════
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatInterval = setInterval(async () => {
+            if (this.currentTaskId) {
+                try {
+                    await this.storage.updateHeartbeat(this.currentTaskId);
+                }
+                catch (err) {
+                    console.warn('Heartbeat update failed:', err);
+                }
+            }
+        }, this.config.heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = undefined;
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CANCELLATION
+    // ═══════════════════════════════════════════════════════════════════════════
+    async requestCancel(taskId) {
+        this.cancelRequested.add(taskId);
+        // If paused, also unpause so cancellation can proceed
+        this.pauseRequested.delete(taskId);
+        this.isPaused = false;
+    }
+    isCancelled(taskId) {
+        return this.cancelRequested.has(taskId);
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // PAUSE / RESUME
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Request pause for the current sync task
+     */
+    requestPause(taskId) {
+        if (taskId === this.currentTaskId) {
+            this.pauseRequested.add(taskId);
+            this.isPaused = true;
+            this.emitProgress();
+        }
+    }
+    /**
+     * Resume a paused sync task
+     */
+    requestResume(taskId) {
+        if (taskId === this.currentTaskId) {
+            this.pauseRequested.delete(taskId);
+            this.isPaused = false;
+            this.emitProgress();
+        }
+    }
+    /**
+     * Check if task should pause (call from indexer loop)
+     */
+    shouldPause(taskId) {
+        return this.pauseRequested.has(taskId);
+    }
+    /**
+     * Wait while paused (call from indexer loop)
+     * Returns true if resumed, false if cancelled during pause
+     */
+    async waitWhilePaused(taskId) {
+        while (this.pauseRequested.has(taskId)) {
+            if (this.cancelRequested.has(taskId)) {
+                return false; // Cancelled during pause
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        return true; // Resumed
+    }
+    /**
+     * Check if currently paused
+     */
+    isPausedNow() {
+        return this.isPaused;
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // PROGRESS CALLBACK
+    // ═══════════════════════════════════════════════════════════════════════════
+    onProgress(callback) {
+        this.onProgressCallback = callback;
+    }
+    onEmbeddingProgress(callback) {
+        this.onEmbeddingProgressCallback = callback;
+    }
+    /**
+     * Get callback for embedding progress (to pass to embedding provider)
+     */
+    getEmbeddingProgressCallback() {
+        return this.onEmbeddingProgressCallback;
+    }
+    onSubPhaseProgress(callback) {
+        this.onSubPhaseProgressCallback = callback;
+    }
+    /**
+     * Emit sub-phase progress (for graph/tree building phases)
+     */
+    emitSubPhaseProgress(current, total, subPhase) {
+        this.onSubPhaseProgressCallback?.(current, total, subPhase);
+    }
+    emitProgress() {
+        const progress = this.getProgress();
+        if (progress && this.onProgressCallback) {
+            this.onProgressCallback(progress);
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // GRACEFUL SHUTDOWN
+    // ═══════════════════════════════════════════════════════════════════════════
+    async shutdown() {
+        this.stopHeartbeat();
+        if (this.currentTaskId) {
+            // Final checkpoint before shutdown
+            await this.checkpoint().catch(() => { });
+        }
+        await this.releaseLock();
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // HELPERS
+    // ═══════════════════════════════════════════════════════════════════════════
+    getCumulativeStats() {
+        const failed = [];
+        if (this.memtable) {
+            for (const [path, info] of this.memtable.failedPaths) {
+                failed.push({ path, error: info.error, retries: info.retries });
+            }
+        }
+        return {
+            added: this.memtable?.stats.added || 0,
+            updated: this.memtable?.stats.updated || 0,
+            deleted: this.memtable?.stats.deleted || 0,
+            failed,
+        };
+    }
+    async cleanup() {
+        this.stopHeartbeat();
+        await this.releaseLock();
+        // Clear cancel/pause requests before resetting taskId
+        if (this.currentTaskId) {
+            this.cancelRequested.delete(this.currentTaskId);
+            this.pauseRequested.delete(this.currentTaskId);
+        }
+        this.isPaused = false;
+        // Reset state
+        this.currentTaskId = null;
+        this.currentTaskType = null;
+        this.memtable = null;
+        this.totalFiles = 0;
+        this.manifestHash = null;
+        this.filesSinceCheckpoint = 0;
+        this.checkpointProcessedCount = 0;
+        this.currentFile = null;
+        this.phase = 'analyzing';
+    }
+    /**
+     * Get current task ID (for external use)
+     */
+    getCurrentTaskId() {
+        return this.currentTaskId;
+    }
+    /**
+     * Check if sync is currently running
+     */
+    isRunning() {
+        return this.currentTaskId !== null;
+    }
+}
+//# sourceMappingURL=sync-wal.js.map