@xenosystem/agent-interface-host 0.1.3

package/dist/codebase/CodebaseIntelligenceService.js

@@ -0,0 +1,1717 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { isAbsolute, join, relative, resolve } from 'path';
+import { buildDependencyGraph } from './dependencyGraph.js';
+import { buildFileIndex, createStats } from './fileIndexer.js';
+import { extractSymbols } from './symbolIndexer.js';
+import { createSnippet, hashText, isPathInside, lineColumnAt, normalizeForSearch, resolveRootDirectory, safeReadJson, safeWriteJson, workspaceIndexDirectory, } from './codeUtils.js';
+import { ContextPackRepository } from './contextPacks.js';
+import { LanguageServerProcessManager } from './LanguageServerProcessManager.js';
+import { summarizeWhatChanged } from './whatChanged.js';
+import { getEngineeringWorkbenchService } from '../engineering/EngineeringWorkbenchService.js';
+const SNAPSHOT_FILE = 'snapshot.json';
+const MANIFEST_FILE = 'manifest.json';
+const CODE_ACTION_PATCH_STORE_FILE = 'code-action-patches.json';
+export class CodebaseIntelligenceService {
+    snapshots = new Map();
+    contextPacks = new ContextPackRepository();
+    languageServers = new LanguageServerProcessManager();
+    async indexWorkspace(request) {
+        try {
+            const rootDirectory = resolveRootDirectory(request.rootDirectory, request.allowedDirectories);
+            const snapshot = this.buildSnapshot(rootDirectory, request);
+            this.snapshots.set(rootDirectory, snapshot);
+            this.saveSnapshot(snapshot);
+            return { success: true, snapshot, stats: snapshot.stats };
+        }
+        catch (err) {
+            return { success: false, error: errorMessage(err) };
+        }
+    }
+    async searchFiles(request) {
+        try {
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const query = normalizeForSearch(request.query || '');
+            const extensions = new Set((request.extensions || []).map((ext) => ext.toLowerCase().startsWith('.') ? ext.toLowerCase() : `.${ext.toLowerCase()}`));
+            const languages = new Set(request.languages || []);
+            const limit = clampLimit(request.limit, 100);
+            const scored = snapshot.files
+                .filter((file) => !extensions.size || extensions.has(file.extension))
+                .filter((file) => !languages.size || languages.has(file.language))
+                .map((file) => ({ file, score: scoreFile(file.relativePath, file.basename, query) }))
+                .filter((entry) => !query || entry.score > 0)
+                .sort((a, b) => b.score - a.score || a.file.relativePath.localeCompare(b.file.relativePath));
+            return { success: true, files: scored.slice(0, limit).map((entry) => entry.file), total: scored.length };
+        }
+        catch (err) {
+            return { success: false, files: [], total: 0, error: errorMessage(err) };
+        }
+    }
+    async searchText(request) {
+        try {
+            if (!request.query || !request.query.trim())
+                return { success: true, results: [], total: 0 };
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const results = this.searchTextSync(snapshot, request);
+            return { success: true, results, total: results.length };
+        }
+        catch (err) {
+            return { success: false, results: [], total: 0, error: errorMessage(err) };
+        }
+    }
+    async listSymbols(request) {
+        try {
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const query = normalizeForSearch(request.query || '');
+            const kinds = new Set(request.kinds || []);
+            const limit = clampLimit(request.limit, 200);
+            const symbols = snapshot.symbols
+                .filter((symbol) => !kinds.size || kinds.has(symbol.kind))
+                .filter((symbol) => !request.pathPrefix || symbol.relativePath.startsWith(request.pathPrefix))
+                .map((symbol) => ({ symbol, score: scoreSymbol(symbol.name, symbol.relativePath, query) }))
+                .filter((entry) => !query || entry.score > 0)
+                .sort((a, b) => b.score - a.score || a.symbol.relativePath.localeCompare(b.symbol.relativePath) || a.symbol.line - b.symbol.line);
+            return { success: true, symbols: symbols.slice(0, limit).map((entry) => entry.symbol), total: symbols.length };
+        }
+        catch (err) {
+            return { success: false, symbols: [], total: 0, error: errorMessage(err) };
+        }
+    }
+    async getSymbol(request) {
+        try {
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const symbol = snapshot.symbols.find((candidate) => candidate.id === request.symbolId);
+            if (!symbol)
+                return { success: false, error: 'Symbol not found.' };
+            const file = snapshot.files.find((candidate) => candidate.absolutePath === symbol.filePath);
+            const references = this.searchTextSync(snapshot, {
+                query: symbol.name,
+                limit: 30,
+            });
+            return { success: true, symbol, file, references };
+        }
+        catch (err) {
+            return { success: false, error: errorMessage(err) };
+        }
+    }
+    async references(request) {
+        try {
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const symbol = request.symbolId ? snapshot.symbols.find((candidate) => candidate.id === request.symbolId) : undefined;
+            const query = request.query || symbol?.name || '';
+            if (!query)
+                return { success: false, results: [], total: 0, error: 'Missing symbolId or query.' };
+            const results = this.searchTextSync(snapshot, {
+                query,
+                limit: request.limit || 100,
+            });
+            return {
+                success: true,
+                results,
+                total: results.length,
+                routing: fallbackIndexRouting(symbol?.language || 'unknown', 'Reference lookup is currently served from the local index when an exact LSP position is not provided.'),
+            };
+        }
+        catch (err) {
+            return { success: false, results: [], total: 0, error: errorMessage(err) };
+        }
+    }
+    async codeActions(request) {
+        try {
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const targetPath = resolveRequestedFilePath(snapshot.rootDirectory, request.filePath);
+            if (!isPathInside(targetPath, snapshot.rootDirectory)) {
+                return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetPath, actions: [], diagnostics: [], error: 'filePath is outside the indexed workspace.' };
+            }
+            const targetFile = snapshot.files.find((file) => normalizePathKey(file.absolutePath) === normalizePathKey(targetPath));
+            if (!targetFile || !targetFile.textContent || !targetFile.isTextIndexed) {
+                return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetPath, actions: [], diagnostics: [], error: 'filePath is not indexed as a text file.' };
+            }
+            if (!isTypeScriptLike(targetFile.extension)) {
+                if (isExternalLspLanguage(targetFile.language)) {
+                    try {
+                        const external = await this.languageServers.codeActions({
+                            rootDirectory: snapshot.rootDirectory,
+                            language: targetFile.language,
+                            filePath: targetFile.absolutePath,
+                            text: targetFile.textContent || '',
+                            line: request.line,
+                            column: request.column,
+                            limit: request.limit,
+                        });
+                        const limit = Math.max(1, Math.min(request.limit || 20, 100));
+                        return {
+                            success: true,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            actions: external.actions.slice(0, limit).map((action) => {
+                                const editPreview = action.editPreview || 'Language server action preview is not available.';
+                                const patchPreview = this.recordPatchPreview({
+                                    id: createPatchPreviewId(editPreview || action.title),
+                                    rootDirectory: snapshot.rootDirectory,
+                                    filePath: targetFile.absolutePath,
+                                    relativePath: targetFile.relativePath,
+                                    title: action.title,
+                                    operation: 'code-action',
+                                    source: action.source,
+                                    serviceId: external.service.id,
+                                    route: 'external-lsp',
+                                    language: targetFile.language,
+                                    files: [targetFile.relativePath],
+                                    editPreview,
+                                    expectedFileHash: targetFile.hash,
+                                });
+                                return {
+                                    id: action.id,
+                                    title: action.title,
+                                    kind: action.kind,
+                                    source: action.source,
+                                    language: targetFile.language,
+                                    serviceId: external.service.id,
+                                    route: 'external-lsp',
+                                    filePath: targetFile.absolutePath,
+                                    relativePath: targetFile.relativePath,
+                                    line: Math.max(1, request.line || 1),
+                                    column: Math.max(1, request.column || 1),
+                                    supportsApply: !!action.rawEdit,
+                                    editPreview,
+                                    patchPreviewId: patchPreview.id,
+                                    patchPreview,
+                                    applyRequires: ['checkpoint', 'patch-preview'],
+                                };
+                            }),
+                            diagnostics: external.diagnostics.map((diagnostic, index) => mapExternalDiagnostic(snapshot.rootDirectory, targetFile, diagnostic, external.service.id, index)),
+                            routing: externalLspRouting(targetFile.language, external.service),
+                        };
+                    }
+                    catch (err) {
+                        const reason = `${targetFile.language} language server unavailable: ${errorMessage(err)}`;
+                        const degradedState = this.degradedStateForLanguage(snapshot.rootDirectory, targetFile.language, reason);
+                        return {
+                            success: false,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            actions: [],
+                            diagnostics: [],
+                            routing: {
+                                ...fallbackIndexRouting(targetFile.language, reason),
+                                serviceId: degradedState.serviceId,
+                                serviceLabel: degradedState.serviceLabel,
+                                installHint: degradedState.installHint,
+                                status: degradedState.status,
+                            },
+                            degradedState,
+                            error: reason,
+                        };
+                    }
+                }
+                return {
+                    success: true,
+                    rootDirectory: snapshot.rootDirectory,
+                    filePath: targetFile.absolutePath,
+                    actions: [],
+                    diagnostics: [],
+                    routing: fallbackIndexRouting(targetFile.language, 'No language server route is configured for this file type.'),
+                    error: 'Project code actions currently support TypeScript and JavaScript files.',
+                };
+            }
+            const ts = await import('typescript');
+            const scriptFiles = snapshot.files.filter((file) => file.textContent && file.isTextIndexed && isTypeScriptLike(file.extension));
+            const fileByPath = new Map(scriptFiles.map((file) => [normalizePathKey(file.absolutePath), file]));
+            const compilerOptions = {
+                allowJs: true,
+                checkJs: false,
+                jsx: ts.JsxEmit.ReactJSX,
+                module: ts.ModuleKind.NodeNext,
+                moduleResolution: ts.ModuleResolutionKind.NodeNext,
+                target: ts.ScriptTarget.ES2022,
+                skipLibCheck: true,
+                strict: false,
+            };
+            const host = {
+                getCompilationSettings: () => compilerOptions,
+                getScriptFileNames: () => scriptFiles.map((file) => file.absolutePath),
+                getScriptVersion: (fileName) => fileByPath.get(normalizePathKey(fileName))?.hash || '0',
+                getScriptSnapshot: (fileName) => {
+                    const file = fileByPath.get(normalizePathKey(fileName));
+                    if (file?.textContent !== undefined)
+                        return ts.ScriptSnapshot.fromString(file.textContent);
+                    const diskText = ts.sys.readFile(fileName);
+                    return diskText === undefined ? undefined : ts.ScriptSnapshot.fromString(diskText);
+                },
+                getCurrentDirectory: () => snapshot.rootDirectory,
+                getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+                useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
+                fileExists: (fileName) => fileByPath.has(normalizePathKey(fileName)) || ts.sys.fileExists(fileName),
+                readFile: (fileName) => fileByPath.get(normalizePathKey(fileName))?.textContent || ts.sys.readFile(fileName),
+                readDirectory: ts.sys.readDirectory,
+                directoryExists: ts.sys.directoryExists,
+                getDirectories: ts.sys.getDirectories,
+                ...(ts.sys.realpath ? { realpath: ts.sys.realpath } : {}),
+            };
+            const languageService = ts.createLanguageService(host, ts.createDocumentRegistry());
+            const diagnostics = [
+                ...languageService.getSyntacticDiagnostics(targetFile.absolutePath),
+                ...languageService.getSemanticDiagnostics(targetFile.absolutePath),
+                ...languageService.getSuggestionDiagnostics(targetFile.absolutePath),
+            ];
+            const mappedDiagnostics = diagnostics
+                .map((diagnostic) => mapTsDiagnostic(ts, snapshot.rootDirectory, targetFile.absolutePath, targetFile.textContent || '', diagnostic))
+                .filter((diagnostic) => !!diagnostic)
+                .map((diagnostic) => ({
+                ...diagnostic,
+                language: targetFile.language,
+                serviceId: 'typescript-language-service',
+                route: 'embedded-typescript',
+            }));
+            const formatOptions = { indentSize: 2, tabSize: 2, convertTabsToSpaces: true, newLineCharacter: '\n' };
+            const preferences = { includeCompletionsForModuleExports: true, includeCompletionsWithInsertText: true };
+            const requestedPosition = offsetAtPosition(targetFile.textContent || '', request.line, request.column);
+            const codeActions = [];
+            const limit = Math.max(1, Math.min(request.limit || 20, 100));
+            for (const diagnostic of diagnostics) {
+                const start = typeof diagnostic.start === 'number' ? diagnostic.start : requestedPosition;
+                const end = start + Math.max(1, diagnostic.length || 1);
+                const fixes = languageService.getCodeFixesAtPosition(targetFile.absolutePath, start, end, [diagnostic.code], formatOptions, preferences);
+                for (const fix of fixes) {
+                    const editPreview = previewTextChanges(snapshot.rootDirectory, fix.changes);
+                    const patchPreview = this.recordPatchPreview({
+                        id: createPatchPreviewId(editPreview),
+                        rootDirectory: snapshot.rootDirectory,
+                        filePath: targetFile.absolutePath,
+                        relativePath: targetFile.relativePath,
+                        title: fix.description,
+                        operation: 'code-action',
+                        source: 'typescript-language-service',
+                        serviceId: 'typescript-language-service',
+                        route: 'embedded-typescript',
+                        language: targetFile.language,
+                        files: textChangeFiles(snapshot.rootDirectory, fix.changes),
+                        editPreview,
+                        expectedFileHash: targetFile.hash,
+                    });
+                    codeActions.push({
+                        id: `fix-${diagnostic.code}-${hashText(fix.fixName + fix.description).slice(0, 10)}`,
+                        title: fix.description,
+                        kind: 'quickfix',
+                        source: 'typescript-language-service',
+                        language: targetFile.language,
+                        serviceId: 'typescript-language-service',
+                        route: 'embedded-typescript',
+                        filePath: targetFile.absolutePath,
+                        relativePath: targetFile.relativePath,
+                        line: mappedDiagnostics.find((entry) => entry.code === String(diagnostic.code))?.line || 1,
+                        column: mappedDiagnostics.find((entry) => entry.code === String(diagnostic.code))?.column || 1,
+                        diagnosticCode: String(diagnostic.code),
+                        fixName: fix.fixName,
+                        supportsApply: fix.changes.length > 0,
+                        editPreview,
+                        patchPreviewId: patchPreview.id,
+                        patchPreview,
+                        applyRequires: ['checkpoint', 'patch-preview'],
+                    });
+                    if (codeActions.length >= limit)
+                        break;
+                }
+                if (codeActions.length >= limit)
+                    break;
+            }
+            if (codeActions.length < limit) {
+                const refactors = languageService.getApplicableRefactors(targetFile.absolutePath, requestedPosition, preferences, undefined);
+                const loc = lineColumnAt(targetFile.textContent || '', requestedPosition);
+                for (const refactor of refactors) {
+                    for (const action of refactor.actions) {
+                        const editPreview = refactor.description;
+                        const patchPreview = this.recordPatchPreview({
+                            id: createPatchPreviewId(`${refactor.name}:${action.name}:${refactor.description}`),
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            relativePath: targetFile.relativePath,
+                            title: action.description || refactor.description,
+                            operation: 'code-action',
+                            source: 'typescript-language-service',
+                            serviceId: 'typescript-language-service',
+                            route: 'embedded-typescript',
+                            language: targetFile.language,
+                            files: [targetFile.relativePath],
+                            editPreview,
+                            expectedFileHash: targetFile.hash,
+                        });
+                        codeActions.push({
+                            id: `refactor-${hashText(refactor.name + action.name).slice(0, 10)}`,
+                            title: action.description || refactor.description,
+                            kind: `refactor.${refactor.name}`,
+                            source: 'typescript-language-service',
+                            language: targetFile.language,
+                            serviceId: 'typescript-language-service',
+                            route: 'embedded-typescript',
+                            filePath: targetFile.absolutePath,
+                            relativePath: targetFile.relativePath,
+                            line: loc.line,
+                            column: loc.column,
+                            refactorName: refactor.name,
+                            refactorActionName: action.name,
+                            supportsApply: true,
+                            editPreview,
+                            patchPreviewId: patchPreview.id,
+                            patchPreview,
+                            applyRequires: ['checkpoint', 'patch-preview'],
+                        });
+                        if (codeActions.length >= limit)
+                            break;
+                    }
+                    if (codeActions.length >= limit)
+                        break;
+                }
+            }
+            languageService.dispose();
+            return {
+                success: true,
+                rootDirectory: snapshot.rootDirectory,
+                filePath: targetFile.absolutePath,
+                actions: codeActions,
+                diagnostics: mappedDiagnostics,
+                routing: embeddedTypeScriptRouting(targetFile.language),
+            };
+        }
+        catch (err) {
+            return { success: false, rootDirectory: request.rootDirectory || '', actions: [], diagnostics: [], error: errorMessage(err) };
+        }
+    }
+    async applyCodeAction(request) {
+        try {
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const target = resolveIndexedTextFile(snapshot, request.filePath);
+            if (!target.success)
+                return { success: false, rootDirectory: snapshot.rootDirectory, filePath: target.filePath, applied: false, edits: [], error: target.error };
+            const targetFile = target.file;
+            if (!isTypeScriptLike(targetFile.extension)) {
+                if (isExternalLspLanguage(targetFile.language)) {
+                    try {
+                        const external = await this.languageServers.codeActions({
+                            rootDirectory: snapshot.rootDirectory,
+                            language: targetFile.language,
+                            filePath: targetFile.absolutePath,
+                            text: targetFile.textContent || '',
+                            line: request.line,
+                            column: request.column,
+                            limit: request.limit,
+                        });
+                        const selected = external.actions.find((action) => matchesRequestedCodeAction(request, {
+                            id: action.id,
+                            title: action.title,
+                            kind: action.kind,
+                        }));
+                        const diagnostics = external.diagnostics.map((diagnostic, index) => mapExternalDiagnostic(snapshot.rootDirectory, targetFile, diagnostic, external.service.id, index));
+                        if (!selected) {
+                            return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], diagnostics, routing: externalLspRouting(targetFile.language, external.service), error: 'Selected external LSP code action was not found for the current file state.' };
+                        }
+                        if (!selected.rawEdit) {
+                            return {
+                                success: false,
+                                rootDirectory: snapshot.rootDirectory,
+                                filePath: targetFile.absolutePath,
+                                applied: false,
+                                edits: [],
+                                diagnostics,
+                                routing: externalLspRouting(targetFile.language, external.service),
+                                deniedReason: 'unsupported-action',
+                                denial: {
+                                    reason: 'unsupported-action',
+                                    remediation: 'Use an LSP action that returns a workspace edit. Arbitrary language-server commands require a configured allowlist before Hub can apply them.',
+                                    requirements: ['checkpoint', 'patch-preview'],
+                                    checkpointId: request.checkpointId,
+                                },
+                                error: 'Selected external LSP action only returned a command. Hub refuses arbitrary language-server commands until command allowlists are configured.',
+                            };
+                        }
+                        const editPreview = selected.editPreview || selected.title;
+                        const previewId = createPatchPreviewId(editPreview);
+                        const patchPreview = this.recordPatchPreview({
+                            id: previewId,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            relativePath: targetFile.relativePath,
+                            title: selected.title,
+                            operation: 'code-action',
+                            source: selected.source,
+                            serviceId: external.service.id,
+                            route: 'external-lsp',
+                            language: targetFile.language,
+                            files: [targetFile.relativePath],
+                            editPreview,
+                            expectedFileHash: targetFile.hash,
+                        });
+                        const safeApplyDenial = validateApplyRequirements(request, previewId);
+                        if (safeApplyDenial) {
+                            const deniedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'denied', { checkpointId: request.checkpointId });
+                            return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], diagnostics, routing: externalLspRouting(targetFile.language, external.service), patchPreview: deniedPreview || patchPreview, ...safeApplyDenial };
+                        }
+                        const edits = applyExternalWorkspaceEdit(snapshot.rootDirectory, selected.rawEdit);
+                        const patchReview = this.enqueueAppliedPatchReview(snapshot.rootDirectory, selected.title, `LSP code action applied with checkpoint ${request.checkpointId}.`, edits, patchPreview);
+                        const rollback = this.recordRollback(snapshot.rootDirectory, request, 'code-action', edits, patchReview?.id);
+                        const appliedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'applied', { checkpointId: request.checkpointId, patchReviewId: patchReview?.id });
+                        this.refreshSnapshot(snapshot.rootDirectory);
+                        return {
+                            success: true,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            applied: edits.some((edit) => edit.changed),
+                            edits,
+                            diagnostics,
+                            patchPreview: appliedPreview || patchPreview,
+                            rollback,
+                            patchReview,
+                            routing: externalLspRouting(targetFile.language, external.service),
+                        };
+                    }
+                    catch (err) {
+                        const reason = `${targetFile.language} language server unavailable: ${errorMessage(err)}`;
+                        const degradedState = this.degradedStateForLanguage(snapshot.rootDirectory, targetFile.language, reason);
+                        return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: { ...fallbackIndexRouting(targetFile.language, reason), serviceId: degradedState.serviceId, serviceLabel: degradedState.serviceLabel, installHint: degradedState.installHint, status: degradedState.status }, degradedState, error: reason };
+                    }
+                }
+                return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: fallbackIndexRouting(targetFile.language, 'No safe apply route is configured for this file type.'), error: 'Code action apply currently supports TypeScript/JavaScript files plus configured external LSP languages.' };
+            }
+            const context = await createTypeScriptLanguageService(snapshot, targetFile, request);
+            try {
+                const diagnostics = [
+                    ...context.languageService.getSyntacticDiagnostics(targetFile.absolutePath),
+                    ...context.languageService.getSemanticDiagnostics(targetFile.absolutePath),
+                    ...context.languageService.getSuggestionDiagnostics(targetFile.absolutePath),
+                ];
+                const requestedPosition = context.requestedPosition;
+                const mappedDiagnostics = diagnostics
+                    .map((diagnostic) => mapTsDiagnostic(context.ts, snapshot.rootDirectory, targetFile.absolutePath, targetFile.textContent || '', diagnostic))
+                    .filter((diagnostic) => !!diagnostic)
+                    .map((diagnostic) => ({
+                    ...diagnostic,
+                    language: targetFile.language,
+                    serviceId: 'typescript-language-service',
+                    route: 'embedded-typescript',
+                }));
+                for (const diagnostic of diagnostics) {
+                    const start = typeof diagnostic.start === 'number' ? diagnostic.start : requestedPosition;
+                    const end = start + Math.max(1, diagnostic.length || 1);
+                    const fixes = context.languageService.getCodeFixesAtPosition(targetFile.absolutePath, start, end, [diagnostic.code], context.formatOptions, context.preferences);
+                    for (const fix of fixes) {
+                        const candidate = {
+                            id: `fix-${diagnostic.code}-${hashText(fix.fixName + fix.description).slice(0, 10)}`,
+                            title: fix.description,
+                            kind: 'quickfix',
+                            diagnosticCode: String(diagnostic.code),
+                            fixName: fix.fixName,
+                        };
+                        if (!matchesRequestedCodeAction(request, candidate))
+                            continue;
+                        const editPreview = previewTextChanges(snapshot.rootDirectory, fix.changes);
+                        const previewId = createPatchPreviewId(editPreview);
+                        const patchPreview = this.recordPatchPreview({
+                            id: previewId,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            relativePath: targetFile.relativePath,
+                            title: fix.description,
+                            operation: 'code-action',
+                            source: 'typescript-language-service',
+                            serviceId: 'typescript-language-service',
+                            route: 'embedded-typescript',
+                            language: targetFile.language,
+                            files: textChangeFiles(snapshot.rootDirectory, fix.changes),
+                            editPreview,
+                            expectedFileHash: targetFile.hash,
+                        });
+                        const safeApplyDenial = validateApplyRequirements(request, previewId);
+                        if (safeApplyDenial) {
+                            const deniedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'denied', { checkpointId: request.checkpointId });
+                            return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], diagnostics: mappedDiagnostics, routing: embeddedTypeScriptRouting(targetFile.language), patchPreview: deniedPreview || patchPreview, ...safeApplyDenial };
+                        }
+                        const edits = applyTsFileTextChanges(snapshot.rootDirectory, fix.changes);
+                        const patchReview = this.enqueueAppliedPatchReview(snapshot.rootDirectory, fix.description, `TypeScript code action applied with checkpoint ${request.checkpointId}.`, edits, patchPreview);
+                        const rollback = this.recordRollback(snapshot.rootDirectory, request, 'code-action', edits, patchReview?.id);
+                        const appliedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'applied', { checkpointId: request.checkpointId, patchReviewId: patchReview?.id });
+                        this.refreshSnapshot(snapshot.rootDirectory);
+                        return {
+                            success: true,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            applied: edits.some((edit) => edit.changed),
+                            edits,
+                            diagnostics: mappedDiagnostics,
+                            patchPreview: appliedPreview || patchPreview,
+                            rollback,
+                            patchReview,
+                            routing: embeddedTypeScriptRouting(targetFile.language),
+                        };
+                    }
+                }
+                const refactors = context.languageService.getApplicableRefactors(targetFile.absolutePath, requestedPosition, context.preferences, undefined);
+                for (const refactor of refactors) {
+                    for (const action of refactor.actions) {
+                        const candidate = {
+                            id: `refactor-${hashText(refactor.name + action.name).slice(0, 10)}`,
+                            title: action.description || refactor.description,
+                            kind: `refactor.${refactor.name}`,
+                            refactorName: refactor.name,
+                            refactorActionName: action.name,
+                        };
+                        if (!matchesRequestedCodeAction(request, candidate))
+                            continue;
+                        const editPreview = refactor.description;
+                        const previewId = createPatchPreviewId(`${refactor.name}:${action.name}:${refactor.description}`);
+                        const patchPreview = this.recordPatchPreview({
+                            id: previewId,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            relativePath: targetFile.relativePath,
+                            title: action.description || refactor.description,
+                            operation: 'code-action',
+                            source: 'typescript-language-service',
+                            serviceId: 'typescript-language-service',
+                            route: 'embedded-typescript',
+                            language: targetFile.language,
+                            files: [targetFile.relativePath],
+                            editPreview,
+                            expectedFileHash: targetFile.hash,
+                        });
+                        const safeApplyDenial = validateApplyRequirements(request, previewId);
+                        if (safeApplyDenial) {
+                            const deniedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'denied', { checkpointId: request.checkpointId });
+                            return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], diagnostics: mappedDiagnostics, routing: embeddedTypeScriptRouting(targetFile.language), patchPreview: deniedPreview || patchPreview, ...safeApplyDenial };
+                        }
+                        const refactorEdit = context.languageService.getEditsForRefactor(targetFile.absolutePath, context.formatOptions, requestedPosition, refactor.name, action.name, context.preferences);
+                        if (!refactorEdit) {
+                            return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: embeddedTypeScriptRouting(targetFile.language), error: 'Selected refactor did not return edits.' };
+                        }
+                        const edits = applyTsFileTextChanges(snapshot.rootDirectory, refactorEdit.edits);
+                        const patchReview = this.enqueueAppliedPatchReview(snapshot.rootDirectory, action.description || refactor.description, `TypeScript refactor applied with checkpoint ${request.checkpointId}.`, edits, patchPreview);
+                        const rollback = this.recordRollback(snapshot.rootDirectory, request, 'code-action', edits, patchReview?.id);
+                        const appliedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'applied', { checkpointId: request.checkpointId, patchReviewId: patchReview?.id });
+                        this.refreshSnapshot(snapshot.rootDirectory);
+                        return {
+                            success: true,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            applied: edits.some((edit) => edit.changed),
+                            edits,
+                            diagnostics: mappedDiagnostics,
+                            patchPreview: appliedPreview || patchPreview,
+                            rollback,
+                            patchReview,
+                            routing: embeddedTypeScriptRouting(targetFile.language),
+                        };
+                    }
+                }
+                return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], diagnostics: mappedDiagnostics, routing: embeddedTypeScriptRouting(targetFile.language), error: 'Selected code action was not found for the current file state.' };
+            }
+            finally {
+                context.languageService.dispose();
+            }
+        }
+        catch (err) {
+            return { success: false, rootDirectory: request.rootDirectory || '', filePath: request.filePath, applied: false, edits: [], error: errorMessage(err) };
+        }
+    }
+    async organizeImports(request) {
+        try {
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const target = resolveIndexedTextFile(snapshot, request.filePath);
+            if (!target.success)
+                return { success: false, rootDirectory: snapshot.rootDirectory, filePath: target.filePath, applied: false, edits: [], error: target.error };
+            const targetFile = target.file;
+            if (!isTypeScriptLike(targetFile.extension)) {
+                if (isExternalLspLanguage(targetFile.language)) {
+                    try {
+                        const external = await this.languageServers.organizeImports({
+                            rootDirectory: snapshot.rootDirectory,
+                            language: targetFile.language,
+                            filePath: targetFile.absolutePath,
+                            text: targetFile.textContent || '',
+                        });
+                        const diagnostics = external.diagnostics.map((diagnostic, index) => mapExternalDiagnostic(snapshot.rootDirectory, targetFile, diagnostic, external.service.id, index));
+                        const action = external.actions.find((candidate) => candidate.rawEdit);
+                        if (!action?.rawEdit) {
+                            return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], diagnostics, routing: externalLspRouting(targetFile.language, external.service), error: 'External language server did not return a safe organize-imports workspace edit.' };
+                        }
+                        const editPreview = action.editPreview || action.title;
+                        const previewId = createPatchPreviewId(`organize:${targetFile.relativePath}:${editPreview}`);
+                        const patchPreview = this.recordPatchPreview({
+                            id: previewId,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            relativePath: targetFile.relativePath,
+                            title: 'Organize imports',
+                            operation: 'organize-imports',
+                            source: action.source,
+                            serviceId: external.service.id,
+                            route: 'external-lsp',
+                            language: targetFile.language,
+                            files: [targetFile.relativePath],
+                            editPreview,
+                            expectedFileHash: targetFile.hash,
+                        });
+                        const safeApplyDenial = validateApplyRequirements(request, previewId);
+                        if (safeApplyDenial) {
+                            const deniedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'denied', { checkpointId: request.checkpointId });
+                            return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], diagnostics, routing: externalLspRouting(targetFile.language, external.service), patchPreview: deniedPreview || patchPreview, ...safeApplyDenial };
+                        }
+                        const edits = applyExternalWorkspaceEdit(snapshot.rootDirectory, action.rawEdit);
+                        const patchReview = this.enqueueAppliedPatchReview(snapshot.rootDirectory, 'Organize imports', `External LSP organize-imports applied with checkpoint ${request.checkpointId}.`, edits, patchPreview);
+                        const rollback = this.recordRollback(snapshot.rootDirectory, request, 'organize-imports', edits, patchReview?.id);
+                        const appliedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'applied', { checkpointId: request.checkpointId, patchReviewId: patchReview?.id });
+                        this.refreshSnapshot(snapshot.rootDirectory);
+                        return {
+                            success: true,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            applied: edits.some((edit) => edit.changed),
+                            edits,
+                            diagnostics,
+                            patchPreview: appliedPreview || patchPreview,
+                            rollback,
+                            patchReview,
+                            routing: externalLspRouting(targetFile.language, external.service),
+                        };
+                    }
+                    catch (err) {
+                        const reason = `${targetFile.language} organize imports unavailable: ${errorMessage(err)}`;
+                        const degradedState = this.degradedStateForLanguage(snapshot.rootDirectory, targetFile.language, reason);
+                        return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: { ...fallbackIndexRouting(targetFile.language, reason), serviceId: degradedState.serviceId, serviceLabel: degradedState.serviceLabel, installHint: degradedState.installHint, status: degradedState.status }, degradedState, error: reason };
+                    }
+                }
+                return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: fallbackIndexRouting(targetFile.language, 'No safe organize-imports route is configured for this file type.'), error: 'Organize imports currently supports TypeScript/JavaScript files plus configured external LSP languages.' };
+            }
+            const context = await createTypeScriptLanguageService(snapshot, targetFile, {});
+            try {
+                const changes = context.languageService.organizeImports({ type: 'file', fileName: targetFile.absolutePath }, context.formatOptions, context.preferences);
+                const editPreview = previewTextChanges(snapshot.rootDirectory, changes) || 'Organize imports';
+                const previewId = createPatchPreviewId(`organize:${targetFile.relativePath}:${editPreview}`);
+                const patchPreview = this.recordPatchPreview({
+                    id: previewId,
+                    rootDirectory: snapshot.rootDirectory,
+                    filePath: targetFile.absolutePath,
+                    relativePath: targetFile.relativePath,
+                    title: 'Organize imports',
+                    operation: 'organize-imports',
+                    source: 'typescript-language-service',
+                    serviceId: 'typescript-language-service',
+                    route: 'embedded-typescript',
+                    language: targetFile.language,
+                    files: textChangeFiles(snapshot.rootDirectory, changes),
+                    editPreview,
+                    expectedFileHash: targetFile.hash,
+                });
+                const safeApplyDenial = validateApplyRequirements(request, previewId);
+                if (safeApplyDenial) {
+                    const deniedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'denied', { checkpointId: request.checkpointId });
+                    return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: embeddedTypeScriptRouting(targetFile.language), patchPreview: deniedPreview || patchPreview, ...safeApplyDenial };
+                }
+                const edits = applyTsFileTextChanges(snapshot.rootDirectory, changes);
+                const patchReview = this.enqueueAppliedPatchReview(snapshot.rootDirectory, 'Organize imports', `TypeScript organize-imports applied with checkpoint ${request.checkpointId}.`, edits, patchPreview);
+                const rollback = this.recordRollback(snapshot.rootDirectory, request, 'organize-imports', edits, patchReview?.id);
+                const appliedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'applied', { checkpointId: request.checkpointId, patchReviewId: patchReview?.id });
+                this.refreshSnapshot(snapshot.rootDirectory);
+                return {
+                    success: true,
+                    rootDirectory: snapshot.rootDirectory,
+                    filePath: targetFile.absolutePath,
+                    applied: edits.some((edit) => edit.changed),
+                    edits,
+                    patchPreview: appliedPreview || patchPreview,
+                    rollback,
+                    patchReview,
+                    routing: embeddedTypeScriptRouting(targetFile.language),
+                };
+            }
+            finally {
+                context.languageService.dispose();
+            }
+        }
+        catch (err) {
+            return { success: false, rootDirectory: request.rootDirectory || '', filePath: request.filePath, applied: false, edits: [], error: errorMessage(err) };
+        }
+    }
+    async renameSymbol(request) {
+        try {
+            const newName = String(request.newName || '').trim();
+            if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(newName)) {
+                return { success: false, rootDirectory: request.rootDirectory || '', filePath: request.filePath, applied: false, edits: [], error: 'newName must be a valid JavaScript/TypeScript identifier.' };
+            }
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const target = resolveIndexedTextFile(snapshot, request.filePath);
+            if (!target.success)
+                return { success: false, rootDirectory: snapshot.rootDirectory, filePath: target.filePath, applied: false, edits: [], error: target.error };
+            const targetFile = target.file;
+            if (!isTypeScriptLike(targetFile.extension)) {
+                if (isExternalLspLanguage(targetFile.language)) {
+                    try {
+                        const external = await this.languageServers.rename({
+                            rootDirectory: snapshot.rootDirectory,
+                            language: targetFile.language,
+                            filePath: targetFile.absolutePath,
+                            text: targetFile.textContent || '',
+                            line: request.line,
+                            column: request.column,
+                            newName,
+                        });
+                        const diagnostics = external.diagnostics.map((diagnostic, index) => mapExternalDiagnostic(snapshot.rootDirectory, targetFile, diagnostic, external.service.id, index));
+                        if (!external.edit) {
+                            return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], diagnostics, routing: externalLspRouting(targetFile.language, external.service), error: 'External language server did not return rename edits.' };
+                        }
+                        const editPreview = `Rename symbol at ${targetFile.relativePath}:${request.line || 1}:${request.column || 1} to ${newName}.`;
+                        const previewId = createPatchPreviewId(`rename:${targetFile.relativePath}:${newName}:${editPreview}`);
+                        const patchPreview = this.recordPatchPreview({
+                            id: previewId,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            relativePath: targetFile.relativePath,
+                            title: `Rename to ${newName}`,
+                            operation: 'rename',
+                            source: 'external-lsp',
+                            serviceId: external.service.id,
+                            route: 'external-lsp',
+                            language: targetFile.language,
+                            files: [targetFile.relativePath],
+                            editPreview,
+                            expectedFileHash: targetFile.hash,
+                        });
+                        const safeApplyDenial = validateApplyRequirements(request, previewId);
+                        if (safeApplyDenial) {
+                            const deniedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'denied', { checkpointId: request.checkpointId });
+                            return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], diagnostics, routing: externalLspRouting(targetFile.language, external.service), patchPreview: deniedPreview || patchPreview, ...safeApplyDenial };
+                        }
+                        const edits = applyExternalWorkspaceEdit(snapshot.rootDirectory, external.edit);
+                        const patchReview = this.enqueueAppliedPatchReview(snapshot.rootDirectory, `Rename to ${newName}`, `External LSP rename applied with checkpoint ${request.checkpointId}.`, edits, patchPreview);
+                        const rollback = this.recordRollback(snapshot.rootDirectory, request, 'rename', edits, patchReview?.id);
+                        const appliedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'applied', { checkpointId: request.checkpointId, patchReviewId: patchReview?.id });
+                        this.refreshSnapshot(snapshot.rootDirectory);
+                        return {
+                            success: true,
+                            rootDirectory: snapshot.rootDirectory,
+                            filePath: targetFile.absolutePath,
+                            applied: edits.some((edit) => edit.changed),
+                            edits,
+                            diagnostics,
+                            patchPreview: appliedPreview || patchPreview,
+                            rollback,
+                            patchReview,
+                            routing: externalLspRouting(targetFile.language, external.service),
+                        };
+                    }
+                    catch (err) {
+                        const reason = `${targetFile.language} rename unavailable: ${errorMessage(err)}`;
+                        const degradedState = this.degradedStateForLanguage(snapshot.rootDirectory, targetFile.language, reason);
+                        return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: { ...fallbackIndexRouting(targetFile.language, reason), serviceId: degradedState.serviceId, serviceLabel: degradedState.serviceLabel, installHint: degradedState.installHint, status: degradedState.status }, degradedState, error: reason };
+                    }
+                }
+                return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: fallbackIndexRouting(targetFile.language, 'No safe rename route is configured for this file type.'), error: 'Rename currently supports TypeScript/JavaScript files plus configured external LSP languages.' };
+            }
+            const context = await createTypeScriptLanguageService(snapshot, targetFile, request);
+            try {
+                const renameInfo = context.languageService.getRenameInfo(targetFile.absolutePath, context.requestedPosition, { allowRenameOfImportPath: false });
+                if (!renameInfo.canRename) {
+                    const message = typeof renameInfo.localizedErrorMessage === 'string' ? renameInfo.localizedErrorMessage : 'Symbol cannot be renamed at this location.';
+                    return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: embeddedTypeScriptRouting(targetFile.language), error: message };
+                }
+                const locations = context.languageService.findRenameLocations(targetFile.absolutePath, context.requestedPosition, false, false, true) || [];
+                if (locations.length === 0) {
+                    return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: embeddedTypeScriptRouting(targetFile.language), error: 'No rename locations were found.' };
+                }
+                const changes = locations.map((location) => ({
+                    fileName: location.fileName,
+                    textChanges: [{ span: location.textSpan, newText: newName }],
+                }));
+                const editPreview = previewTextChanges(snapshot.rootDirectory, changes) || `Rename to ${newName}`;
+                const previewId = createPatchPreviewId(`rename:${targetFile.relativePath}:${newName}:${editPreview}`);
+                const patchPreview = this.recordPatchPreview({
+                    id: previewId,
+                    rootDirectory: snapshot.rootDirectory,
+                    filePath: targetFile.absolutePath,
+                    relativePath: targetFile.relativePath,
+                    title: `Rename to ${newName}`,
+                    operation: 'rename',
+                    source: 'typescript-language-service',
+                    serviceId: 'typescript-language-service',
+                    route: 'embedded-typescript',
+                    language: targetFile.language,
+                    files: textChangeFiles(snapshot.rootDirectory, changes),
+                    editPreview,
+                    expectedFileHash: targetFile.hash,
+                });
+                const safeApplyDenial = validateApplyRequirements(request, previewId);
+                if (safeApplyDenial) {
+                    const deniedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'denied', { checkpointId: request.checkpointId });
+                    return { success: false, rootDirectory: snapshot.rootDirectory, filePath: targetFile.absolutePath, applied: false, edits: [], routing: embeddedTypeScriptRouting(targetFile.language), patchPreview: deniedPreview || patchPreview, ...safeApplyDenial };
+                }
+                const edits = applyTsFileTextChanges(snapshot.rootDirectory, changes);
+                const patchReview = this.enqueueAppliedPatchReview(snapshot.rootDirectory, `Rename to ${newName}`, `TypeScript rename applied with checkpoint ${request.checkpointId}.`, edits, patchPreview);
+                const rollback = this.recordRollback(snapshot.rootDirectory, request, 'rename', edits, patchReview?.id);
+                const appliedPreview = this.markPatchPreview(snapshot.rootDirectory, previewId, 'applied', { checkpointId: request.checkpointId, patchReviewId: patchReview?.id });
+                this.refreshSnapshot(snapshot.rootDirectory);
+                return {
+                    success: true,
+                    rootDirectory: snapshot.rootDirectory,
+                    filePath: targetFile.absolutePath,
+                    applied: edits.some((edit) => edit.changed),
+                    edits,
+                    patchPreview: appliedPreview || patchPreview,
+                    rollback,
+                    patchReview,
+                    routing: embeddedTypeScriptRouting(targetFile.language),
+                };
+            }
+            finally {
+                context.languageService.dispose();
+            }
+        }
+        catch (err) {
+            return { success: false, rootDirectory: request.rootDirectory || '', filePath: request.filePath, applied: false, edits: [], error: errorMessage(err) };
+        }
+    }
+    languageServiceStatus(request) {
+        try {
+            const rootDirectory = resolveRootDirectory(request.rootDirectory, request.allowedDirectories);
+            const checkedAt = Date.now();
+            return {
+                success: true,
+                rootDirectory,
+                services: [
+                    {
+                        id: 'typescript-language-service',
+                        label: 'TypeScript language service',
+                        languages: ['typescript', 'tsx', 'javascript', 'jsx'],
+                        mode: 'embedded',
+                        status: 'ready',
+                        detail: 'Embedded TypeScript language service for diagnostics, quick fixes, rename, organize imports, and refactors.',
+                        capabilities: ['diagnostics', 'hover', 'definition', 'references', 'rename', 'codeActions', 'organizeImports'],
+                        degraded: false,
+                        lastCheckedAt: checkedAt,
+                    },
+                    ...this.languageServers.status(rootDirectory, checkedAt),
+                ],
+            };
+        }
+        catch (err) {
+            return { success: false, rootDirectory: request.rootDirectory || '', services: [], error: errorMessage(err) };
+        }
+    }
+    controlLanguageService(request) {
+        try {
+            const rootDirectory = resolveRootDirectory(request.rootDirectory, request.allowedDirectories);
+            if (request.action !== 'start' && request.action !== 'stop' && request.action !== 'restart') {
+                throw new Error('action must be start, stop, or restart.');
+            }
+            if (!request.serviceId || request.serviceId === 'typescript-language-service') {
+                throw new Error('serviceId must be an external language service id.');
+            }
+            const service = this.languageServers.control(rootDirectory, request.serviceId, request.action);
+            return { success: true, rootDirectory, service };
+        }
+        catch (err) {
+            return { success: false, rootDirectory: request.rootDirectory || '', error: errorMessage(err) };
+        }
+    }
+    repairIndex(request) {
+        const startedAt = Date.now();
+        try {
+            const rootDirectory = resolveRootDirectory(request.rootDirectory, request.allowedDirectories);
+            const existing = this.loadSnapshot(rootDirectory);
+            const removedFiles = (existing?.files || [])
+                .filter((file) => !existsSync(file.absolutePath))
+                .map((file) => file.relativePath);
+            const shouldRebuild = request.force === true || !existing || removedFiles.length > 0;
+            let rebuilt;
+            if (shouldRebuild) {
+                rebuilt = this.refreshSnapshot(rootDirectory, request).stats;
+            }
+            return {
+                success: true,
+                rootDirectory,
+                repaired: shouldRebuild,
+                removedFiles,
+                rebuilt,
+                durationMs: Date.now() - startedAt,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                rootDirectory: request.rootDirectory || '',
+                repaired: false,
+                removedFiles: [],
+                durationMs: Date.now() - startedAt,
+                error: errorMessage(err),
+            };
+        }
+    }
+    async dependencyGraph(request) {
+        try {
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const maxNodes = request.maxNodes ? Math.max(1, request.maxNodes) : undefined;
+            if (!maxNodes || snapshot.dependencyGraph.nodes.length <= maxNodes) {
+                return { success: true, graph: snapshot.dependencyGraph };
+            }
+            return {
+                success: true,
+                graph: {
+                    ...snapshot.dependencyGraph,
+                    nodes: snapshot.dependencyGraph.nodes.slice(0, maxNodes),
+                    edges: snapshot.dependencyGraph.edges.filter((edge) => (snapshot.dependencyGraph.nodes.slice(0, maxNodes).some((node) => node.id === edge.from)
+                        && snapshot.dependencyGraph.nodes.slice(0, maxNodes).some((node) => node.id === edge.to))),
+                },
+            };
+        }
+        catch (err) {
+            return { success: false, error: errorMessage(err) };
+        }
+    }
+    async createContextPack(request) {
+        try {
+            const rootDirectory = resolveRootDirectory(request.rootDirectory, request.allowedDirectories);
+            return { success: true, pack: this.contextPacks.create(rootDirectory, request) };
+        }
+        catch (err) {
+            return { success: false, error: errorMessage(err) };
+        }
+    }
+    async updateContextPack(request) {
+        try {
+            const rootDirectory = resolveRootDirectory(request.rootDirectory, request.allowedDirectories);
+            return { success: true, pack: this.contextPacks.update(rootDirectory, request) };
+        }
+        catch (err) {
+            return { success: false, error: errorMessage(err) };
+        }
+    }
+    async listContextPacks(request) {
+        try {
+            const rootDirectory = resolveRootDirectory(request.rootDirectory, request.allowedDirectories);
+            return { success: true, packs: this.contextPacks.list(rootDirectory) };
+        }
+        catch (err) {
+            return { success: false, packs: [], error: errorMessage(err) };
+        }
+    }
+    async materializeContextPack(request) {
+        try {
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            const materialized = this.contextPacks.materialize({
+                rootDirectory: snapshot.rootDirectory,
+                packId: request.id,
+                files: snapshot.files,
+                symbols: snapshot.symbols,
+                maxTokens: request.maxTokens,
+                searchText: (query, limit) => this.searchTextSync(snapshot, { query, limit }),
+            });
+            return { success: true, materialized };
+        }
+        catch (err) {
+            return { success: false, error: errorMessage(err) };
+        }
+    }
+    async whatChanged(request) {
+        try {
+            const snapshot = await this.ensureIndexed(request.rootDirectory, request.allowedDirectories);
+            return summarizeWhatChanged(snapshot.rootDirectory, snapshot.files, request.maxFiles);
+        }
+        catch (err) {
+            return {
+                success: false,
+                isGitRepo: false,
+                rootDirectory: request.rootDirectory,
+                summary: '',
+                changedFiles: [],
+                workPacket: '',
+                error: errorMessage(err),
+            };
+        }
+    }
+    recordPatchPreview(draft) {
+        const now = Date.now();
+        const store = this.readPatchStore(draft.rootDirectory);
+        const id = draft.id || createPatchPreviewId(`${draft.title}:${draft.editPreview}:${draft.expectedFileHash || ''}`);
+        const existing = store.previews.find((preview) => preview.id === id);
+        const preview = {
+            id,
+            rootDirectory: draft.rootDirectory,
+            filePath: draft.filePath,
+            relativePath: draft.relativePath,
+            title: draft.title,
+            operation: draft.operation,
+            source: draft.source,
+            serviceId: draft.serviceId,
+            route: draft.route,
+            language: draft.language,
+            files: [...new Set(draft.files.map((file) => file.replace(/\\/g, '/')).filter(Boolean))],
+            editPreview: draft.editPreview || 'No textual preview was returned.',
+            diff: draft.diff || draft.editPreview || 'No textual preview was returned.',
+            expectedFileHash: draft.expectedFileHash,
+            status: existing?.status === 'applied' ? 'applied' : 'previewed',
+            checkpointId: existing?.checkpointId,
+            patchReviewId: existing?.patchReviewId,
+            createdAt: existing?.createdAt || now,
+            updatedAt: now,
+        };
+        store.previews = [preview, ...store.previews.filter((entry) => entry.id !== id)].slice(0, 200);
+        this.writePatchStore(draft.rootDirectory, store);
+        return preview;
+    }
+    markPatchPreview(rootDirectory, previewId, status, metadata = {}) {
+        if (!previewId)
+            return undefined;
+        const store = this.readPatchStore(rootDirectory);
+        const preview = store.previews.find((entry) => entry.id === previewId);
+        if (!preview)
+            return undefined;
+        preview.status = status;
+        preview.updatedAt = Date.now();
+        preview.checkpointId = metadata.checkpointId || preview.checkpointId;
+        preview.patchReviewId = metadata.patchReviewId || preview.patchReviewId;
+        this.writePatchStore(rootDirectory, store);
+        return preview;
+    }
+    recordRollback(rootDirectory, request, operation, edits, patchReviewId) {
+        const checkpointId = String(request.checkpointId || '').trim();
+        if (!checkpointId)
+            return undefined;
+        const rollback = {
+            id: `rollback-${Date.now()}-${hashText(`${checkpointId}:${request.patchPreviewId || ''}:${edits.map((edit) => `${edit.relativePath}:${edit.afterHash || ''}`).join('|')}`).slice(0, 10)}`,
+            rootDirectory,
+            checkpointId,
+            patchPreviewId: request.patchPreviewId,
+            patchReviewId,
+            operation,
+            createdAt: Date.now(),
+            files: edits.map((edit) => ({
+                filePath: edit.filePath,
+                relativePath: edit.relativePath,
+                beforeHash: edit.beforeHash || '',
+                afterHash: edit.afterHash || '',
+                changed: edit.changed,
+                editCount: edit.editCount,
+            })),
+            instructions: 'Use the checkpointId to restore the workspace through the workbench checkpoint/rollback flow; hashes identify the exact files changed by this LSP apply.',
+        };
+        const store = this.readPatchStore(rootDirectory);
+        store.rollbacks = [rollback, ...store.rollbacks.filter((entry) => entry.id !== rollback.id)].slice(0, 200);
+        this.writePatchStore(rootDirectory, store);
+        return rollback;
+    }
+    enqueueAppliedPatchReview(rootDirectory, title, description, edits, patchPreview) {
+        const changedEdits = edits.filter((edit) => edit.changed);
+        const diff = changedEdits.map((edit) => `# ${edit.relativePath}\n${edit.preview}`).join('\n\n').trim();
+        if (!diff)
+            return undefined;
+        const review = getEngineeringWorkbenchService().enqueuePatchReview({
+            rootDirectory,
+            title,
+            description,
+            diff,
+            files: changedEdits.map((edit) => edit.relativePath),
+            source: 'agent',
+            id: patchPreview?.patchReviewId || patchPreview?.id?.replace(/^patch-preview-/, 'patch-review-lsp-'),
+        });
+        if (!review.success || !review.item)
+            return undefined;
+        getEngineeringWorkbenchService().updatePatchReview({
+            rootDirectory,
+            id: review.item.id,
+            status: 'applied',
+            notes: description,
+        });
+        return { id: review.item.id, status: 'applied', source: 'agent' };
+    }
+    readPatchStore(rootDirectory) {
+        return safeReadJson(this.patchStorePath(rootDirectory), { version: 1, previews: [], rollbacks: [] });
+    }
+    writePatchStore(rootDirectory, store) {
+        safeWriteJson(this.patchStorePath(rootDirectory), {
+            version: 1,
+            previews: store.previews.slice(0, 200),
+            rollbacks: store.rollbacks.slice(0, 200),
+        });
+    }
+    patchStorePath(rootDirectory) {
+        return join(workspaceIndexDirectory(rootDirectory), CODE_ACTION_PATCH_STORE_FILE);
+    }
+    degradedStateForLanguage(rootDirectory, language, reason) {
+        const service = this.languageServers.status(rootDirectory).find((entry) => entry.languages.includes(language));
+        return {
+            degraded: true,
+            reason,
+            serviceId: service?.id || 'codebase-index',
+            serviceLabel: service?.label || 'Codebase index',
+            status: service?.status,
+            installHint: service?.installHint,
+            capabilities: service?.capabilities || ['searchFiles', 'searchText', 'symbols', 'dependencies'],
+        };
+    }
+    async ensureIndexed(rootDirectoryInput, allowedDirectories) {
+        const rootDirectory = resolveRootDirectory(rootDirectoryInput, allowedDirectories);
+        const cached = this.snapshots.get(rootDirectory);
+        if (cached)
+            return cached;
+        const loaded = this.loadSnapshot(rootDirectory);
+        if (loaded) {
+            this.snapshots.set(rootDirectory, loaded);
+            return loaded;
+        }
+        const snapshot = this.buildSnapshot(rootDirectory, { rootDirectory });
+        this.snapshots.set(rootDirectory, snapshot);
+        this.saveSnapshot(snapshot);
+        return snapshot;
+    }
+    buildSnapshot(rootDirectory, request) {
+        const startedAt = Date.now();
+        const fileResult = buildFileIndex({
+            rootDirectory,
+            maxFiles: request.maxFiles,
+            maxFileBytes: request.maxFileBytes,
+        });
+        const symbols = extractSymbols(fileResult.files);
+        const dependencyGraph = buildDependencyGraph(rootDirectory, fileResult.files, symbols);
+        const fingerprint = hashText(fileResult.files.map((file) => `${file.relativePath}:${file.size}:${Math.round(file.mtimeMs)}:${file.hash}`).join('\n'));
+        const stats = createStats({
+            rootDirectory,
+            startedAt,
+            files: fileResult.files,
+            ignoredCount: fileResult.ignoredCount,
+            truncated: fileResult.truncated,
+            totalBytes: fileResult.totalBytes,
+            indexedBytes: fileResult.indexedBytes,
+            symbolCount: symbols.length,
+            dependencyNodeCount: dependencyGraph.nodes.length,
+            dependencyEdgeCount: dependencyGraph.edges.length,
+        });
+        return {
+            version: 1,
+            rootDirectory,
+            fingerprint,
+            builtAt: Date.now(),
+            files: fileResult.files,
+            symbols,
+            dependencyGraph,
+            stats,
+        };
+    }
+    searchTextSync(snapshot, request) {
+        const query = request.query.trim();
+        const normalizedQuery = normalizeForSearch(query);
+        const extensions = new Set((request.extensions || []).map((ext) => ext.toLowerCase().startsWith('.') ? ext.toLowerCase() : `.${ext.toLowerCase()}`));
+        const limit = clampLimit(request.limit, 100);
+        const results = [];
+        for (const file of snapshot.files) {
+            if (results.length >= limit)
+                break;
+            if (!file.textContent || !file.isTextIndexed)
+                continue;
+            if (request.pathPrefix && !file.relativePath.startsWith(request.pathPrefix))
+                continue;
+            if (extensions.size && !extensions.has(file.extension))
+                continue;
+            const lower = file.textContent.toLowerCase();
+            let index = lower.indexOf(normalizedQuery);
+            if (index < 0) {
+                const terms = normalizedQuery.split(/\s+/).filter(Boolean);
+                if (!terms.every((term) => lower.includes(term)))
+                    continue;
+                index = Math.min(...terms.map((term) => lower.indexOf(term)).filter((pos) => pos >= 0));
+            }
+            const loc = lineColumnAt(file.textContent, index);
+            results.push({
+                file,
+                line: loc.line,
+                column: loc.column,
+                snippet: createSnippet(file.textContent, query),
+                score: scoreTextMatch(file.relativePath, lower, normalizedQuery, index),
+                content: request.includeContent ? file.textContent : undefined,
+            });
+        }
+        return results.sort((a, b) => b.score - a.score || a.file.relativePath.localeCompare(b.file.relativePath));
+    }
+    loadSnapshot(rootDirectory) {
+        const snapshotPath = join(workspaceIndexDirectory(rootDirectory), SNAPSHOT_FILE);
+        const snapshot = safeReadJson(snapshotPath, null);
+        if (!snapshot || snapshot.version !== 1 || snapshot.rootDirectory !== rootDirectory)
+            return null;
+        return snapshot;
+    }
+    saveSnapshot(snapshot) {
+        const dir = workspaceIndexDirectory(snapshot.rootDirectory);
+        safeWriteJson(join(dir, SNAPSHOT_FILE), snapshot);
+        safeWriteJson(join(dir, MANIFEST_FILE), {
+            version: snapshot.version,
+            rootDirectory: snapshot.rootDirectory,
+            fingerprint: snapshot.fingerprint,
+            builtAt: snapshot.builtAt,
+            stats: snapshot.stats,
+        });
+    }
+    refreshSnapshot(rootDirectory, request) {
+        const snapshot = this.buildSnapshot(rootDirectory, { rootDirectory, ...request });
+        this.snapshots.set(rootDirectory, snapshot);
+        this.saveSnapshot(snapshot);
+        return snapshot;
+    }
+}
+function embeddedTypeScriptRouting(language) {
+    return {
+        route: 'embedded-typescript',
+        serviceId: 'typescript-language-service',
+        serviceLabel: 'TypeScript language service',
+        language,
+        degraded: false,
+        capabilities: ['diagnostics', 'hover', 'definition', 'references', 'rename', 'codeActions', 'organizeImports'],
+    };
+}
+function externalLspRouting(language, service) {
+    return {
+        route: 'external-lsp',
+        serviceId: service.id,
+        serviceLabel: service.label,
+        language,
+        degraded: service.degraded === true,
+        degradedReason: service.degradedReason,
+        installHint: service.installHint,
+        status: service.status,
+        capabilities: service.capabilities || ['diagnostics', 'hover', 'definition', 'references', 'rename', 'codeActions'],
+    };
+}
+function fallbackIndexRouting(language, degradedReason) {
+    return {
+        route: 'fallback-index',
+        serviceId: 'codebase-index',
+        serviceLabel: 'Codebase index',
+        language,
+        degraded: true,
+        degradedReason,
+        capabilities: ['searchFiles', 'searchText', 'symbols', 'dependencies'],
+    };
+}
+function createPatchPreviewId(preview) {
+    return `patch-preview-${hashText(preview || 'no-preview').slice(0, 16)}`;
+}
+function validateApplyRequirements(request, expectedPatchPreviewId) {
+    if (!request.checkpointId || !request.checkpointId.trim()) {
+        const remediation = 'Create an undo checkpoint, review the generated patch preview, then retry apply with checkpointId and patchPreviewAccepted=true.';
+        return {
+            deniedReason: 'missing-checkpoint',
+            denial: {
+                reason: 'missing-checkpoint',
+                remediation,
+                requirements: ['checkpoint', 'patch-preview'],
+                patchPreviewId: expectedPatchPreviewId,
+            },
+            error: `Refusing to apply code changes without a checkpointId. ${remediation}`,
+        };
+    }
+    if (request.patchPreviewAccepted !== true) {
+        const remediation = 'Open and accept the patch preview before applying LSP edits.';
+        return {
+            deniedReason: 'missing-patch-preview',
+            denial: {
+                reason: 'missing-patch-preview',
+                remediation,
+                requirements: ['checkpoint', 'patch-preview'],
+                patchPreviewId: expectedPatchPreviewId,
+                checkpointId: request.checkpointId,
+            },
+            error: `Refusing to apply code changes without an accepted patch preview. ${remediation}`,
+        };
+    }
+    if (expectedPatchPreviewId && request.patchPreviewId && request.patchPreviewId !== expectedPatchPreviewId) {
+        const reason = 'stale-patch-preview';
+        const remediation = 'Refresh code actions and accept the current patch preview before applying.';
+        return {
+            deniedReason: reason,
+            denial: {
+                reason,
+                remediation,
+                requirements: ['checkpoint', 'patch-preview'],
+                patchPreviewId: expectedPatchPreviewId,
+                checkpointId: request.checkpointId,
+            },
+            error: `Refusing to apply code changes because the patch preview is missing or no longer matches the selected action. ${remediation}`,
+        };
+    }
+    return null;
+}
+function scoreFile(relativePath, basename, query) {
+    if (!query)
+        return 1;
+    const path = normalizeForSearch(relativePath);
+    const name = normalizeForSearch(basename);
+    if (name === query)
+        return 100;
+    if (name.includes(query))
+        return 80;
+    if (path.includes(query))
+        return 50;
+    const terms = query.split(/\s+/).filter(Boolean);
+    return terms.every((term) => path.includes(term)) ? 25 + terms.length : 0;
+}
+function scoreSymbol(name, relativePath, query) {
+    if (!query)
+        return 1;
+    const n = normalizeForSearch(name);
+    const p = normalizeForSearch(relativePath);
+    if (n === query)
+        return 100;
+    if (n.includes(query))
+        return 75;
+    if (p.includes(query))
+        return 30;
+    const terms = query.split(/\s+/).filter(Boolean);
+    return terms.every((term) => n.includes(term) || p.includes(term)) ? 20 + terms.length : 0;
+}
+function scoreTextMatch(relativePath, lowerContent, normalizedQuery, index) {
+    let score = 20;
+    if (index === 0)
+        score += 10;
+    if (normalizeForSearch(relativePath).includes(normalizedQuery))
+        score += 8;
+    const occurrences = normalizedQuery ? lowerContent.split(normalizedQuery).length - 1 : 0;
+    return score + Math.min(occurrences, 20);
+}
+function resolveRequestedFilePath(rootDirectory, filePath) {
+    const raw = String(filePath || '').trim();
+    if (!raw)
+        throw new Error('filePath is required.');
+    return resolve(isAbsolute(raw) ? raw : join(rootDirectory, raw));
+}
+function normalizePathKey(filePath) {
+    const resolved = resolve(filePath);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+function isTypeScriptLike(extension) {
+    return extension === '.ts' || extension === '.tsx' || extension === '.js' || extension === '.jsx' || extension === '.mjs' || extension === '.cjs';
+}
+function isExternalLspLanguage(language) {
+    return language === 'python' || language === 'rust' || language === 'go' || language === 'cpp' || language === 'csharp';
+}
+function resolveIndexedTextFile(snapshot, filePath) {
+    const targetPath = resolveRequestedFilePath(snapshot.rootDirectory, filePath);
+    if (!isPathInside(targetPath, snapshot.rootDirectory)) {
+        return { success: false, filePath: targetPath, error: 'filePath is outside the indexed workspace.' };
+    }
+    const targetFile = snapshot.files.find((file) => normalizePathKey(file.absolutePath) === normalizePathKey(targetPath));
+    if (!targetFile || !targetFile.textContent || !targetFile.isTextIndexed) {
+        return { success: false, filePath: targetPath, error: 'filePath is not indexed as a text file.' };
+    }
+    return { success: true, file: targetFile, filePath: targetFile.absolutePath };
+}
+async function createTypeScriptLanguageService(snapshot, targetFile, request) {
+    const ts = await import('typescript');
+    const scriptFiles = snapshot.files.filter((file) => file.textContent && file.isTextIndexed && isTypeScriptLike(file.extension));
+    const fileByPath = new Map(scriptFiles.map((file) => [normalizePathKey(file.absolutePath), file]));
+    const compilerOptions = {
+        allowJs: true,
+        checkJs: false,
+        jsx: ts.JsxEmit.ReactJSX,
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+        target: ts.ScriptTarget.ES2022,
+        skipLibCheck: true,
+        strict: false,
+    };
+    const host = {
+        getCompilationSettings: () => compilerOptions,
+        getScriptFileNames: () => scriptFiles.map((file) => file.absolutePath),
+        getScriptVersion: (fileName) => fileByPath.get(normalizePathKey(fileName))?.hash || '0',
+        getScriptSnapshot: (fileName) => {
+            const file = fileByPath.get(normalizePathKey(fileName));
+            if (file?.textContent !== undefined)
+                return ts.ScriptSnapshot.fromString(file.textContent);
+            const diskText = ts.sys.readFile(fileName);
+            return diskText === undefined ? undefined : ts.ScriptSnapshot.fromString(diskText);
+        },
+        getCurrentDirectory: () => snapshot.rootDirectory,
+        getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+        useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
+        fileExists: (fileName) => fileByPath.has(normalizePathKey(fileName)) || ts.sys.fileExists(fileName),
+        readFile: (fileName) => fileByPath.get(normalizePathKey(fileName))?.textContent || ts.sys.readFile(fileName),
+        readDirectory: ts.sys.readDirectory,
+        directoryExists: ts.sys.directoryExists,
+        getDirectories: ts.sys.getDirectories,
+        ...(ts.sys.realpath ? { realpath: ts.sys.realpath } : {}),
+    };
+    return {
+        ts,
+        languageService: ts.createLanguageService(host, ts.createDocumentRegistry()),
+        formatOptions: { indentSize: 2, tabSize: 2, convertTabsToSpaces: true, newLineCharacter: '\n' },
+        preferences: { includeCompletionsForModuleExports: true, includeCompletionsWithInsertText: true },
+        requestedPosition: offsetAtPosition(targetFile.textContent || '', request.line, request.column),
+    };
+}
+function matchesRequestedCodeAction(request, candidate) {
+    if (request.actionId && request.actionId === candidate.id)
+        return true;
+    if (request.diagnosticCode && request.diagnosticCode !== candidate.diagnosticCode)
+        return false;
+    if (request.kind && request.kind !== candidate.kind)
+        return false;
+    if (request.title && request.title !== candidate.title)
+        return false;
+    return !request.actionId && (!!request.title || !!request.diagnosticCode || !!request.kind);
+}
+function applyTsFileTextChanges(rootDirectory, changes) {
+    const grouped = new Map();
+    for (const change of changes) {
+        const absolutePath = resolve(change.fileName);
+        if (!isPathInside(absolutePath, rootDirectory)) {
+            throw new Error(`Refusing to edit file outside workspace: ${change.fileName}`);
+        }
+        grouped.set(absolutePath, [...(grouped.get(absolutePath) || []), ...change.textChanges]);
+    }
+    const summaries = [];
+    for (const [filePath, textChanges] of grouped) {
+        const before = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '';
+        let after = before;
+        const sorted = [...textChanges].sort((a, b) => b.span.start - a.span.start);
+        for (const textChange of sorted) {
+            const start = Math.max(0, Math.min(after.length, textChange.span.start));
+            const end = Math.max(start, Math.min(after.length, start + textChange.span.length));
+            after = `${after.slice(0, start)}${textChange.newText}${after.slice(end)}`;
+        }
+        const changed = after !== before;
+        if (changed) {
+            writeFileSync(filePath, after, 'utf-8');
+        }
+        summaries.push({
+            filePath,
+            relativePath: relative(rootDirectory, filePath).replace(/\\/g, '/'),
+            changed,
+            editCount: textChanges.length,
+            preview: previewAppliedEdits(before, after, textChanges),
+            beforeHash: hashText(before),
+            afterHash: hashText(after),
+        });
+    }
+    return summaries;
+}
+function applyExternalWorkspaceEdit(rootDirectory, workspaceEdit) {
+    const editsByFile = collectExternalWorkspaceEdits(workspaceEdit);
+    const summaries = [];
+    for (const [uri, edits] of editsByFile) {
+        const filePath = resolve(decodeFileUri(uri));
+        if (!isPathInside(filePath, rootDirectory)) {
+            throw new Error(`Refusing to apply LSP edit outside workspace: ${uri}`);
+        }
+        if (!existsSync(filePath)) {
+            throw new Error(`Refusing to apply LSP edit to missing file: ${filePath}`);
+        }
+        const before = readFileSync(filePath, 'utf-8');
+        let after = before;
+        const normalized = edits
+            .map((edit) => {
+            const start = offsetAtLspPosition(before, edit.startLine, edit.startCharacter);
+            const end = offsetAtLspPosition(before, edit.endLine, edit.endCharacter);
+            return { start: Math.min(start, end), end: Math.max(start, end), newText: edit.newText };
+        })
+            .sort((a, b) => b.start - a.start || b.end - a.end);
+        for (const edit of normalized) {
+            after = `${after.slice(0, edit.start)}${edit.newText}${after.slice(edit.end)}`;
+        }
+        const changed = before !== after;
+        if (changed) {
+            writeFileSync(filePath, after, 'utf-8');
+        }
+        summaries.push({
+            filePath,
+            relativePath: relative(rootDirectory, filePath).replace(/\\/g, '/'),
+            changed,
+            editCount: normalized.length,
+            preview: previewExternalAppliedEdits(before, after, normalized),
+            beforeHash: hashText(before),
+            afterHash: hashText(after),
+        });
+    }
+    return summaries;
+}
+function collectExternalWorkspaceEdits(workspaceEdit) {
+    const record = asPlainRecord(workspaceEdit);
+    const result = new Map();
+    const changes = asPlainRecord(record.changes);
+    for (const [uri, edits] of Object.entries(changes)) {
+        appendExternalTextEdits(result, uri, edits);
+    }
+    const documentChanges = Array.isArray(record.documentChanges) ? record.documentChanges : [];
+    for (const change of documentChanges) {
+        const changeRecord = asPlainRecord(change);
+        if (typeof changeRecord.kind === 'string') {
+            throw new Error(`Refusing unsupported LSP resource operation: ${changeRecord.kind}`);
+        }
+        const textDocument = asPlainRecord(changeRecord.textDocument);
+        const uri = typeof textDocument.uri === 'string' ? textDocument.uri : '';
+        if (!uri)
+            continue;
+        appendExternalTextEdits(result, uri, changeRecord.edits);
+    }
+    return result;
+}
+function appendExternalTextEdits(target, uri, edits) {
+    if (!uri.startsWith('file://'))
+        throw new Error(`Refusing non-file LSP edit target: ${uri}`);
+    if (!Array.isArray(edits))
+        return;
+    const parsed = edits
+        .map((edit) => parseExternalTextEdit(edit))
+        .filter((edit) => !!edit);
+    if (!parsed.length)
+        return;
+    target.set(uri, [...(target.get(uri) || []), ...parsed]);
+}
+function parseExternalTextEdit(edit) {
+    const record = asPlainRecord(edit);
+    const range = asPlainRecord(record.range);
+    const start = asPlainRecord(range.start);
+    const end = asPlainRecord(range.end);
+    if (typeof record.newText !== 'string')
+        return null;
+    return {
+        startLine: finiteNumber(start.line),
+        startCharacter: finiteNumber(start.character),
+        endLine: finiteNumber(end.line),
+        endCharacter: finiteNumber(end.character),
+        newText: record.newText,
+    };
+}
+function offsetAtLspPosition(content, zeroBasedLine, zeroBasedCharacter) {
+    const lines = content.split(/\r?\n/);
+    let offset = 0;
+    const safeLine = Math.max(0, Math.min(zeroBasedLine, lines.length - 1));
+    for (let index = 0; index < safeLine; index += 1) {
+        offset += lines[index].length + 1;
+    }
+    return Math.max(0, Math.min(content.length, offset + Math.max(0, zeroBasedCharacter)));
+}
+function previewExternalAppliedEdits(before, after, edits) {
+    if (before === after)
+        return 'No textual changes were required.';
+    return edits.slice(0, 10).map((edit) => {
+        const loc = lineColumnAt(before, edit.start);
+        const inserted = edit.newText.replace(/\s+/g, ' ').trim();
+        return `${loc.line}:${loc.column} ${inserted ? inserted.slice(0, 180) : '[remove text]'}`;
+    }).join('\n');
+}
+function previewAppliedEdits(before, after, textChanges) {
+    if (before === after)
+        return 'No textual changes were required.';
+    const lines = [];
+    for (const textChange of textChanges.slice(0, 10)) {
+        const loc = lineColumnAt(before, textChange.span.start);
+        const inserted = textChange.newText.replace(/\s+/g, ' ').trim();
+        lines.push(`${loc.line}:${loc.column} ${inserted ? inserted.slice(0, 180) : '[remove text]'}`);
+    }
+    return lines.join('\n');
+}
+function offsetAtPosition(content, line, column) {
+    if (!line || !column || line < 1 || column < 1)
+        return 0;
+    const lines = content.split(/\r?\n/);
+    let offset = 0;
+    for (let index = 0; index < Math.min(line - 1, lines.length); index += 1) {
+        offset += lines[index].length + 1;
+    }
+    return Math.max(0, Math.min(content.length, offset + column - 1));
+}
+function mapTsDiagnostic(ts, rootDirectory, fallbackFilePath, fallbackContent, diagnostic) {
+    const filePath = diagnostic.file?.fileName || fallbackFilePath;
+    const content = diagnostic.file?.text || fallbackContent;
+    const loc = lineColumnAt(content, typeof diagnostic.start === 'number' ? diagnostic.start : 0);
+    const category = diagnostic.category === ts.DiagnosticCategory.Warning
+        ? 'warning'
+        : diagnostic.category === ts.DiagnosticCategory.Message || diagnostic.category === ts.DiagnosticCategory.Suggestion
+            ? 'info'
+            : 'error';
+    const absolutePath = resolve(filePath);
+    const relativePath = isPathInside(absolutePath, rootDirectory)
+        ? relative(rootDirectory, absolutePath).replace(/\\/g, '/')
+        : filePath;
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    return {
+        id: `ts-${diagnostic.code}-${hashText(`${relativePath}:${diagnostic.start}:${message}`).slice(0, 10)}`,
+        filePath: absolutePath,
+        relativePath,
+        line: loc.line,
+        column: loc.column,
+        severity: category,
+        source: 'typescript-language-service',
+        code: String(diagnostic.code),
+        message,
+    };
+}
+function mapExternalDiagnostic(rootDirectory, targetFile, diagnostic, source, index) {
+    const idPayload = `${targetFile.relativePath}:${diagnostic.line}:${diagnostic.column}:${diagnostic.code || ''}:${diagnostic.message}`;
+    return {
+        id: `lsp-${source}-${hashText(idPayload).slice(0, 10)}`,
+        filePath: targetFile.absolutePath,
+        relativePath: isPathInside(targetFile.absolutePath, rootDirectory)
+            ? relative(rootDirectory, targetFile.absolutePath).replace(/\\/g, '/')
+            : targetFile.relativePath,
+        line: diagnostic.line,
+        column: diagnostic.column,
+        severity: diagnostic.severity,
+        source,
+        language: targetFile.language,
+        serviceId: source,
+        route: 'external-lsp',
+        code: diagnostic.code || String(index + 1),
+        message: diagnostic.message,
+    };
+}
+function previewTextChanges(rootDirectory, changes) {
+    const lines = [];
+    for (const change of changes.slice(0, 8)) {
+        const fileLabel = isPathInside(change.fileName, rootDirectory)
+            ? relative(rootDirectory, change.fileName).replace(/\\/g, '/')
+            : change.fileName;
+        for (const textChange of change.textChanges.slice(0, 8)) {
+            const cleanText = textChange.newText.replace(/\s+/g, ' ').trim();
+            lines.push(`${fileLabel}: ${cleanText ? cleanText.slice(0, 180) : '[remove text]'}`);
+            if (lines.length >= 12)
+                break;
+        }
+        if (lines.length >= 12)
+            break;
+    }
+    return lines.join('\n');
+}
+function textChangeFiles(rootDirectory, changes) {
+    const files = changes.map((change) => {
+        const absolutePath = resolve(change.fileName);
+        return isPathInside(absolutePath, rootDirectory)
+            ? relative(rootDirectory, absolutePath).replace(/\\/g, '/')
+            : change.fileName.replace(/\\/g, '/');
+    });
+    return [...new Set(files)];
+}
+function clampLimit(limit, fallback) {
+    return Math.max(1, Math.min(1000, limit || fallback));
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function asPlainRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function decodeFileUri(uri) {
+    if (!uri.startsWith('file://'))
+        return uri;
+    const withoutScheme = uri.slice('file://'.length);
+    try {
+        return decodeURIComponent(withoutScheme.replace(/^\//, ''));
+    }
+    catch {
+        return withoutScheme.replace(/^\//, '');
+    }
+}
+let singleton = null;
+export function getCodebaseIntelligenceService() {
+    if (!singleton)
+        singleton = new CodebaseIntelligenceService();
+    return singleton;
+}
+//# sourceMappingURL=CodebaseIntelligenceService.js.map