@suco/su-auggie-mcp 0.1.0

package/dist/workspace.js

@@ -0,0 +1,697 @@
+/**
+ * Per-workspace manager: DirectContext + chokidar + ignore + FileIndexer
+ *
+ * All indexing is delegated to FileIndexer for centralized file-level error handling.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { DirectContext, APIError } from '@augmentcode/auggie-sdk';
+import chokidar from 'chokidar';
+import { INDEXING_CONFIG, WATCHER_CONFIG, PERSISTENCE_CONFIG, isPersistenceEnabled } from './config.js';
+import { createIgnoreFilter, shouldIgnore } from './ignore-filter.js';
+import { createLogger } from './logger.js';
+import { sendLogToClient } from './mcp-notifications.js';
+import { FileIndexer } from './file-indexer.js';
+const logger = createLogger('Workspace');
+/**
+ * Retry an async operation with exponential backoff.
+ */
+async function retryWithBackoff(operation, operationName, maxRetries = INDEXING_CONFIG.MAX_RETRIES) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (err) {
+            lastError = err;
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            // Fatal errors don't retry
+            if (err instanceof APIError && (err.status === 401 || err.status === 403)) {
+                throw err;
+            }
+            if (attempt < maxRetries) {
+                const delay = INDEXING_CONFIG.RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+                logger.info(`${operationName} failed (attempt ${attempt + 1}/${maxRetries + 1}): ${errorMsg}, retrying in ${Math.round(delay)}ms`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw lastError;
+}
+/** Workspace manager for a single workspace root */
+export class Workspace {
+    root;
+    context = null;
+    watcher = null;
+    ignoreFilter;
+    status = 'initializing';
+    error = null;
+    lastIndexed = null;
+    progress = null;
+    changeQueue = [];
+    debounceTimer = null;
+    initialScanComplete = false;
+    // FileIndexer handles all indexing, retries, and cooldown
+    fileIndexer = null;
+    // Timing tracking
+    indexingStartTime = null;
+    initialIndexSeconds = null;
+    lastDeltaSeconds = null;
+    // Drift reconciliation stats
+    driftDeletedFiles = 0;
+    driftModifiedFiles = 0;
+    driftReconciled = false;
+    driftReconcileTimeMs = null;
+    // Track if we restored from persisted state
+    restoredFromPersistence = false;
+    // File metadata for mtime-based change detection
+    fileMetadata = {};
+    restoredMetadata = null;
+    constructor(root) {
+        this.root = path.resolve(root);
+        this.ignoreFilter = createIgnoreFilter(this.root);
+    }
+    /** Create and initialize a workspace */
+    static async create(root) {
+        const workspace = new Workspace(root);
+        await workspace.initialize();
+        return workspace;
+    }
+    /** Initialize the workspace: restore state, start watcher, initial index */
+    async initialize() {
+        try {
+            // Try to restore from persisted state (if persistence enabled)
+            const statePath = this.getStatePath();
+            if (isPersistenceEnabled() && fs.existsSync(statePath)) {
+                logger.info(`Restoring state from ${statePath}`);
+                try {
+                    this.context = await DirectContext.importFromFile(statePath);
+                    this.restoredFromPersistence = true;
+                    const indexedCount = this.context.getIndexedPaths().length;
+                    logger.info(`Restored ${indexedCount} indexed paths from persistence`);
+                    // Load file metadata for mtime-based change detection
+                    this.restoredMetadata = this.loadMetadata();
+                }
+                catch (importErr) {
+                    // State file corrupted, delete and start fresh
+                    const msg = importErr instanceof Error ? importErr.message : String(importErr);
+                    logger.warn(`Failed to import state (${msg}), starting fresh`);
+                    fs.unlinkSync(statePath);
+                    this.context = await DirectContext.create();
+                    this.restoredFromPersistence = false;
+                    this.restoredMetadata = null;
+                }
+            }
+            else {
+                logger.info(`Creating new context for ${this.root}`);
+                this.context = await DirectContext.create();
+                this.restoredFromPersistence = false;
+                this.restoredMetadata = null;
+            }
+            // Create FileIndexer (handles all indexing, retries, cooldown)
+            this.fileIndexer = new FileIndexer(this.context, this.root);
+            // Start file watcher
+            this.startWatcher();
+            // Start initial indexing
+            this.status = 'indexing';
+            this.performInitialIndex().catch(err => {
+                this.handleError('Failed during initial indexing', err);
+            });
+        }
+        catch (err) {
+            this.handleError('Failed to initialize workspace', err);
+        }
+    }
+    /**
+     * Re-initialize workspace after auth becomes available.
+     * Called when credentials are detected after initial startup failure.
+     */
+    async reinitialize() {
+        if (this.status !== 'error') {
+            logger.debug(`Workspace ${this.root} not in error state, skipping reinit`);
+            return;
+        }
+        logger.info(`Re-initializing workspace ${this.root} after auth`);
+        sendLogToClient('info', `Re-initializing workspace: ${this.root}`);
+        // Reset error state
+        this.error = null;
+        // Try to initialize again
+        await this.initialize();
+    }
+    /** Get path to state file */
+    getStatePath() {
+        return path.join(this.root, PERSISTENCE_CONFIG.STATE_DIR, PERSISTENCE_CONFIG.STATE_FILE);
+    }
+    /** Get path to metadata file */
+    getMetadataPath() {
+        return path.join(this.root, PERSISTENCE_CONFIG.STATE_DIR, PERSISTENCE_CONFIG.METADATA_FILE);
+    }
+    /** Ensure state directory exists */
+    ensureStateDir() {
+        const stateDir = path.join(this.root, PERSISTENCE_CONFIG.STATE_DIR);
+        if (!fs.existsSync(stateDir)) {
+            fs.mkdirSync(stateDir, { recursive: true });
+        }
+    }
+    /** Save state to disk (if persistence enabled) */
+    async saveState() {
+        if (!this.context || !isPersistenceEnabled())
+            return;
+        try {
+            this.ensureStateDir();
+            await this.context.exportToFile(this.getStatePath());
+            logger.debug(`Saved state to ${this.getStatePath()}`);
+        }
+        catch (err) {
+            logger.warn('Failed to save state', err);
+        }
+    }
+    /** Save file metadata to disk (if persistence enabled) */
+    saveMetadata() {
+        if (!isPersistenceEnabled())
+            return;
+        try {
+            this.ensureStateDir();
+            const persisted = {
+                version: 1,
+                savedAt: new Date().toISOString(),
+                files: this.fileMetadata,
+            };
+            fs.writeFileSync(this.getMetadataPath(), JSON.stringify(persisted), 'utf-8');
+            logger.debug(`Saved metadata for ${Object.keys(this.fileMetadata).length} files`);
+        }
+        catch (err) {
+            logger.warn('Failed to save metadata', err);
+        }
+    }
+    /** Load file metadata from disk (returns null if not found or invalid) */
+    loadMetadata() {
+        if (!isPersistenceEnabled())
+            return null;
+        const metadataPath = this.getMetadataPath();
+        if (!fs.existsSync(metadataPath))
+            return null;
+        try {
+            const content = fs.readFileSync(metadataPath, 'utf-8');
+            const persisted = JSON.parse(content);
+            // Validate version
+            if (persisted.version !== 1) {
+                logger.warn(`Unknown metadata version ${persisted.version}, ignoring`);
+                return null;
+            }
+            logger.info(`Loaded metadata for ${Object.keys(persisted.files).length} files (saved at ${persisted.savedAt})`);
+            return persisted.files;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`Failed to load metadata (${msg}), will rebuild`);
+            return null;
+        }
+    }
+    /** Start file watcher */
+    startWatcher() {
+        this.watcher = chokidar.watch(this.root, {
+            ignored: (filePath) => {
+                const relativePath = path.relative(this.root, filePath);
+                if (!relativePath)
+                    return false;
+                return shouldIgnore(this.ignoreFilter, relativePath);
+            },
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+        });
+        this.watcher
+            .on('add', (filePath) => this.queueChange({ type: 'add', path: filePath }))
+            .on('change', (filePath) => this.queueChange({ type: 'change', path: filePath }))
+            .on('unlink', (filePath) => this.queueChange({ type: 'unlink', path: filePath }))
+            .on('error', (err) => logger.error('Watcher error', err));
+        logger.debug(`Started watcher for ${this.root}`);
+    }
+    /** Queue a file change for debounced processing */
+    queueChange(change) {
+        if (!this.initialScanComplete)
+            return;
+        this.changeQueue.push(change);
+        this.scheduleFlush();
+    }
+    /** Schedule a debounced flush of the change queue */
+    scheduleFlush() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.flushChangeQueue().catch(err => {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.error(`Change queue flush failed: ${msg}`);
+            });
+        }, WATCHER_CONFIG.DEBOUNCE_MS);
+    }
+    /** Flush the change queue and process changes using FileIndexer */
+    async flushChangeQueue() {
+        if (this.changeQueue.length === 0 || !this.fileIndexer)
+            return;
+        const startTime = Date.now();
+        const changes = [...this.changeQueue];
+        this.changeQueue = [];
+        const toAdd = [];
+        const toRemove = [];
+        for (const change of changes) {
+            const relativePath = path.relative(this.root, change.path);
+            if (change.type === 'unlink') {
+                toRemove.push(relativePath);
+            }
+            else {
+                toAdd.push(change.path);
+            }
+        }
+        try {
+            // Remove deleted files using FileIndexer
+            if (toRemove.length > 0) {
+                await this.fileIndexer.removeFiles(toRemove);
+                // Remove metadata for deleted files
+                for (const removedPath of toRemove) {
+                    delete this.fileMetadata[removedPath];
+                }
+            }
+            // Index new/changed files using FileIndexer
+            if (toAdd.length > 0) {
+                const result = await this.fileIndexer.indexFiles(toAdd);
+                // Update metadata from FileIndexer result
+                Object.assign(this.fileMetadata, result.metadata);
+            }
+            await this.saveState();
+            this.saveMetadata();
+            this.lastIndexed = new Date();
+            // Log and track delta timing
+            const elapsedMs = Date.now() - startTime;
+            this.lastDeltaSeconds = Math.round(elapsedMs / 100) / 10;
+            const totalChanges = toAdd.length + toRemove.length;
+            const msg = `Delta update: ${totalChanges} files (${toAdd.length} added, ${toRemove.length} removed) in ${elapsedMs}ms`;
+            logger.info(msg);
+            sendLogToClient('info', msg);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error(`Error processing file changes: ${msg}`);
+        }
+    }
+    /**
+     * Reconcile drift between persisted index and current filesystem state.
+     * Detects files deleted or modified while MCP was offline.
+     * Only runs when persistence is enabled and we restored from persisted state.
+     * @returns Set of paths that are still valid and unchanged (not deleted or modified)
+     */
+    async reconcileDrift(indexedPaths) {
+        const validPaths = new Set();
+        // Skip if no persistence or fresh start
+        if (!isPersistenceEnabled() || !this.restoredFromPersistence || indexedPaths.length === 0) {
+            logger.debug('Skipping drift reconciliation (no persistence or fresh start)');
+            this.driftReconciled = false;
+            return new Set(indexedPaths);
+        }
+        const startTime = Date.now();
+        const hasMetadata = this.restoredMetadata !== null;
+        logger.info(`Reconciling drift for ${indexedPaths.length} indexed files (mtime check: ${hasMetadata})...`);
+        sendLogToClient('info', `Checking ${indexedPaths.length} indexed files for drift...`);
+        const toRemove = [];
+        const toReindex = [];
+        // Check each indexed path
+        for (const relativePath of indexedPaths) {
+            const absolutePath = path.join(this.root, relativePath);
+            try {
+                const stat = fs.statSync(absolutePath);
+                // File exists - check if it's now ignored
+                if (shouldIgnore(this.ignoreFilter, relativePath)) {
+                    // File now matches ignore pattern - remove from index
+                    toRemove.push(relativePath);
+                    this.driftDeletedFiles++;
+                    logger.debug(`File now ignored, removing: ${relativePath}`);
+                    continue;
+                }
+                // Check for modification using mtime (if we have stored metadata)
+                if (hasMetadata && this.restoredMetadata) {
+                    const storedMeta = this.restoredMetadata[relativePath];
+                    if (storedMeta) {
+                        // Compare mtime (allow 1ms tolerance for filesystem precision)
+                        const mtimeDiff = Math.abs(stat.mtimeMs - storedMeta.mtimeMs);
+                        const sizeChanged = stat.size !== storedMeta.size;
+                        if (mtimeDiff > 1 || sizeChanged) {
+                            // File was modified - queue for re-indexing (by NOT adding to validPaths)
+                            toReindex.push(relativePath);
+                            this.driftModifiedFiles++;
+                            logger.debug(`File modified (mtime diff: ${mtimeDiff}ms, size: ${storedMeta.size}->${stat.size}): ${relativePath}`);
+                            continue;
+                        }
+                    }
+                    else {
+                        // No stored metadata for this file - treat as valid but log
+                        logger.debug(`No stored metadata for indexed file: ${relativePath}`);
+                    }
+                }
+                // File is valid and unchanged
+                validPaths.add(relativePath);
+                // Preserve existing metadata for unchanged files
+                if (hasMetadata && this.restoredMetadata?.[relativePath]) {
+                    this.fileMetadata[relativePath] = this.restoredMetadata[relativePath];
+                }
+            }
+            catch {
+                // File doesn't exist - queue for removal
+                toRemove.push(relativePath);
+                this.driftDeletedFiles++;
+                logger.debug(`File deleted, removing from index: ${relativePath}`);
+            }
+        }
+        // Remove deleted/ignored files from index
+        if (toRemove.length > 0 && this.fileIndexer) {
+            try {
+                await this.fileIndexer.removeFiles(toRemove);
+                logger.info(`Removed ${toRemove.length} deleted/ignored files from index`);
+                sendLogToClient('info', `Removed ${toRemove.length} stale files from index`);
+                // Also remove from stored metadata
+                for (const removedPath of toRemove) {
+                    delete this.fileMetadata[removedPath];
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.error(`Failed to remove stale files: ${msg}`);
+            }
+        }
+        // Remove modified files from index so they can be re-indexed
+        if (toReindex.length > 0 && this.fileIndexer) {
+            try {
+                await this.fileIndexer.removeFiles(toReindex);
+                logger.info(`Removed ${toReindex.length} modified files for re-indexing`);
+                sendLogToClient('info', `Will re-index ${toReindex.length} modified files`);
+                // Clear metadata for files that will be re-indexed
+                for (const modifiedPath of toReindex) {
+                    delete this.fileMetadata[modifiedPath];
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.error(`Failed to remove modified files: ${msg}`);
+            }
+        }
+        this.driftReconciled = true;
+        this.driftReconcileTimeMs = Date.now() - startTime;
+        if (toRemove.length > 0 || toReindex.length > 0) {
+            const msg = `Drift reconciliation: ${toRemove.length} deleted, ${toReindex.length} modified (${this.driftReconcileTimeMs}ms)`;
+            logger.info(msg);
+            sendLogToClient('info', msg);
+        }
+        else {
+            logger.info(`No drift detected (${this.driftReconcileTimeMs}ms)`);
+        }
+        // Clear restored metadata - we've processed it
+        this.restoredMetadata = null;
+        return validPaths;
+    }
+    /** Perform initial indexing using FileIndexer */
+    async performInitialIndex() {
+        if (!this.fileIndexer || !this.context)
+            return;
+        const startTime = Date.now();
+        const isColdStart = (this.context.getIndexedPaths().length) === 0;
+        try {
+            const indexedPaths = this.context.getIndexedPaths();
+            // Reconcile drift before processing (removes deleted files, respects -n flag)
+            const indexedSet = await this.reconcileDrift(indexedPaths);
+            // Initialize progress
+            this.progress = {
+                discovered: 0,
+                indexed: 0,
+                discovering: true,
+                batchesQueued: 0,
+                batchesCompleted: 0,
+                batchesFailed: 0,
+                batchesRetried: 0,
+            };
+            this.indexingStartTime = new Date();
+            // Reset FileIndexer stats for fresh indexing
+            this.fileIndexer.resetStats();
+            // Discover files to index
+            const filesToIndex = [];
+            for (const absolutePath of this.discoverFiles(indexedSet)) {
+                filesToIndex.push(absolutePath);
+                this.progress.discovered++;
+            }
+            this.progress.discovering = false;
+            // Hot start - nothing to index
+            if (filesToIndex.length === 0) {
+                const elapsedMs = Date.now() - startTime;
+                const totalFiles = this.context.getIndexedPaths().length;
+                const msg = `Hot start: ${totalFiles} files already indexed, scan took ${elapsedMs}ms - ${this.root}`;
+                logger.info(msg);
+                sendLogToClient('info', msg);
+                this.status = 'ready';
+                this.initialScanComplete = true;
+                this.progress = null;
+                return;
+            }
+            const discoveredMsg = `Discovered ${filesToIndex.length} files in ${this.root}...`;
+            logger.info(discoveredMsg);
+            sendLogToClient('info', discoveredMsg);
+            // Index files using FileIndexer (handles batching, retries, cooldown)
+            const result = await this.fileIndexer.indexFiles(filesToIndex, (indexed, total, message) => {
+                if (this.progress) {
+                    this.progress.indexed = indexed;
+                    const pct = total > 0 ? Math.round((indexed / total) * 100) : 0;
+                    const msg = `Indexed: ${indexed}/${total} (${pct}%) - ${message}`;
+                    logger.info(msg);
+                    sendLogToClient('info', msg);
+                }
+            });
+            // Update metadata from FileIndexer result
+            Object.assign(this.fileMetadata, result.metadata);
+            // Wait for backend to finish indexing
+            await retryWithBackoff(() => this.context.waitForIndexing(), 'waitForIndexing');
+            await this.saveState();
+            this.saveMetadata();
+            this.lastIndexed = new Date();
+            this.status = 'ready';
+            this.initialScanComplete = true;
+            // Calculate timing
+            const elapsedMs = Date.now() - startTime;
+            const elapsedSeconds = Math.round(elapsedMs / 1000 * 10) / 10;
+            const totalIndexed = this.context.getIndexedPaths().length;
+            const indexType = isColdStart ? 'Cold start' : 'Hot re-index';
+            const stats = this.fileIndexer.getStats();
+            const metrics = this.fileIndexer.getBatcherMetrics();
+            const filesPerSec = elapsedMs > 0 ? Math.round(totalIndexed / (elapsedMs / 1000)) : 0;
+            // Store timing for status reporting
+            if (isColdStart) {
+                this.initialIndexSeconds = elapsedSeconds;
+            }
+            else {
+                this.lastDeltaSeconds = elapsedSeconds;
+            }
+            // Build completion message
+            let completeMsg = `${indexType} complete: ${totalIndexed} files in ${elapsedSeconds}s (${filesPerSec} files/sec, peak concurrency: ${metrics.peakConcurrency})`;
+            if (stats.recovered > 0) {
+                completeMsg += `, ${stats.recovered} files recovered via retry`;
+            }
+            if (stats.failed > 0) {
+                completeMsg += `, ${stats.failed} files permanently failed`;
+            }
+            if (stats.skipped > 0) {
+                completeMsg += `, ${stats.skipped} files skipped`;
+            }
+            logger.info(completeMsg);
+            sendLogToClient('info', completeMsg);
+            this.progress = null;
+            this.indexingStartTime = null;
+        }
+        catch (err) {
+            this.handleError('Initial indexing failed', err);
+        }
+    }
+    /**
+     * Generator that discovers files for indexing.
+     * Yields absolute paths of files that need indexing.
+     */
+    *discoverFiles(indexedSet) {
+        const walk = function* (dir, root, ignoreFilter) {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const absolutePath = path.join(dir, entry.name);
+                    const relativePath = path.relative(root, absolutePath);
+                    if (shouldIgnore(ignoreFilter, relativePath))
+                        continue;
+                    if (entry.isDirectory()) {
+                        yield* walk(absolutePath, root, ignoreFilter);
+                    }
+                    else if (entry.isFile()) {
+                        yield absolutePath;
+                    }
+                }
+            }
+            catch {
+                // Ignore permission errors
+            }
+        };
+        for (const absolutePath of walk(this.root, this.root, this.ignoreFilter)) {
+            const relativePath = path.relative(this.root, absolutePath);
+            // Skip already indexed files
+            if (indexedSet.has(relativePath))
+                continue;
+            yield absolutePath;
+        }
+    }
+    /** Get drift reconciliation statistics */
+    getDriftStats() {
+        return {
+            deletedFiles: this.driftDeletedFiles,
+            modifiedFiles: this.driftModifiedFiles,
+            reconciled: this.driftReconciled,
+            reconcileTimeMs: this.driftReconcileTimeMs,
+        };
+    }
+    /** Handle errors */
+    handleError(message, err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        logger.error(`${message}: ${errorMessage}`);
+        this.status = 'error';
+        this.error = errorMessage;
+    }
+    /** Get workspace status */
+    getStatus() {
+        // Pending = discovered but not yet indexed + change queue
+        const progressPending = this.progress
+            ? this.progress.discovered - this.progress.indexed
+            : 0;
+        // Get stats from FileIndexer
+        const stats = this.fileIndexer?.getStats() ?? {
+            indexed: 0,
+            skipped: 0,
+            failed: 0,
+            recovered: 0,
+            pendingRetry: 0,
+            pendingCooldown: 0,
+            cooldownCycle: 0,
+            cooldownNextRetryAt: null,
+        };
+        const metrics = this.fileIndexer?.getBatcherMetrics() ?? {
+            currentConcurrency: 0,
+            peakConcurrency: 0,
+            concurrencyBounds: { min: 0, max: 0 },
+            batchLimits: { maxFiles: 0, maxBytes: 0 },
+        };
+        // Add concurrency to progress if available
+        const progressWithConcurrency = this.progress
+            ? { ...this.progress, concurrency: metrics.currentConcurrency }
+            : undefined;
+        // Calculate live elapsed time during indexing
+        const elapsedSeconds = this.indexingStartTime && this.status === 'indexing'
+            ? Math.round((Date.now() - this.indexingStartTime.getTime()) / 100) / 10
+            : null;
+        const driftStats = this.getDriftStats();
+        // Build retry stats from FileIndexer
+        const retryStats = {
+            pendingRetries: 0,
+            pendingRetryFiles: stats.pendingRetry,
+            retriedBatches: 0,
+            retriedFiles: stats.recovered,
+            permanentlyFailedBatches: 0,
+            permanentlyFailedFiles: stats.failed,
+            cooldown: {
+                pendingFiles: stats.pendingCooldown,
+                currentCycle: stats.cooldownCycle,
+                maxCycles: INDEXING_CONFIG.MAX_COOLDOWN_CYCLES,
+                nextRetryAt: stats.cooldownNextRetryAt,
+                recoveredFiles: 0,
+            },
+        };
+        // Calculate pending (change queue + retry queue + cooldown)
+        const pending = this.changeQueue.length + progressPending + stats.pendingRetry + stats.pendingCooldown;
+        // Calculate total = indexed + skipped + failed + pending
+        const indexed = stats.indexed;
+        const total = indexed + stats.skipped + stats.failed + pending;
+        return {
+            root: this.root,
+            status: this.status,
+            total,
+            skipped: stats.skipped,
+            failed: stats.failed,
+            pending,
+            indexed,
+            watching: this.watcher !== null,
+            lastIndexed: this.lastIndexed?.toISOString() ?? null,
+            error: this.error ?? undefined,
+            progress: progressWithConcurrency,
+            timing: {
+                startedAt: this.indexingStartTime?.toISOString() ?? null,
+                elapsedSeconds,
+                initialIndexSeconds: this.initialIndexSeconds,
+                lastDeltaSeconds: this.lastDeltaSeconds,
+            },
+            retry: retryStats,
+            concurrency: {
+                current: metrics.currentConcurrency,
+                peak: metrics.peakConcurrency,
+                bounds: metrics.concurrencyBounds,
+                batchLimits: metrics.batchLimits,
+            },
+            drift: driftStats.reconciled ? driftStats : undefined,
+        };
+    }
+    /** Get indexed paths */
+    getIndexedPaths() {
+        return this.context?.getIndexedPaths() ?? [];
+    }
+    /** Search the codebase */
+    async search(query) {
+        if (!this.context) {
+            throw new Error('Workspace not initialized');
+        }
+        // Trigger retry of failed files if conditions are met (fire and forget)
+        this.triggerRetryIfNeeded();
+        return this.context.search(query);
+    }
+    /** Search and ask */
+    async searchAndAsk(query, prompt) {
+        if (!this.context) {
+            throw new Error('Workspace not initialized');
+        }
+        // Trigger retry of failed files if conditions are met (fire and forget)
+        this.triggerRetryIfNeeded();
+        return this.context.searchAndAsk(query, prompt);
+    }
+    /**
+     * Trigger retry of failed files if conditions are met.
+     * This is a "hit and run" call - triggers async retry and returns immediately.
+     */
+    triggerRetryIfNeeded() {
+        this.fileIndexer?.triggerRetryIfNeeded();
+    }
+    /** Force reindex */
+    async reindex(full = false) {
+        if (!this.context) {
+            throw new Error('Workspace not initialized');
+        }
+        if (full) {
+            await this.context.clearIndex();
+            // Clear file metadata for full reindex
+            this.fileMetadata = {};
+        }
+        this.status = 'indexing';
+        await this.performInitialIndex();
+    }
+    /** Close the workspace */
+    async close() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        // Close FileIndexer (handles its own timers)
+        this.fileIndexer?.close();
+        if (this.watcher) {
+            await this.watcher.close();
+        }
+        await this.saveState();
+        this.saveMetadata();
+        logger.debug(`Closed workspace ${this.root}`);
+    }
+}