@akira-tl/forgerelay 0.4.4 → 0.4.5

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.4.5] - 2026-08-11
+
+### Added
+
+- Added Host-to-LSP cancellation propagation, bounded per-service semantic concurrency/queueing, and stable request timeout/cancellation/capacity errors without exposing arbitrary Agent-controlled timeout values.
+- Added aggregate Language-service runtime telemetry for service/process/request/document/diagnostic/stderr retention without logging source contents or paths.
+
+### Changed
+
+- Language services now retry one unexpected server crash, enter a bounded cooldown after repeated crashes, and invalidate only affected services when the effective server-definition fingerprint changes.
+- Language-service lifecycle now distinguishes truly idle services from cancellation-ignoring requests, evicts only the least-recently-used safe idle service at capacity, shares one service across logical workspaces on the same physical project, and releases managed-worktree services before finalization.
+- Idle shutdown and repeated open/query/config/crash cycles now explicitly release and bound server processes, synchronized documents, diagnostic snapshots, request state, stderr tails, and service counts.
+
 ## [0.4.4] - 2026-08-11
 
 ### Added

package/capabilities/code-intelligence/GUIDE.md

@@ -15,3 +15,9 @@ Diagnostics use the same normalized result contract for push and pull providers.
 Semantic locations may identify External code locations outside the Workspace, but that does not expand ForgeRelay's allowed roots or grant the file tools permission to read those paths.
 
 Language-server definitions use structured process configuration rather than shell command strings. A project configuration entry may contain `command`, `args`, `env`, `languages`, `extensions`, `languageIdByExtension`, `projectMarkers`, and `enabled` fields. Use `languageIdByExtension` when one server definition covers multiple language IDs whose extensions do not map one-to-one by array position. The server command is launched directly without a shell.
+
+Semantic Language-server requests use an internal bounded deadline; the Agent contract does not expose arbitrary timeout controls. Host cancellation is propagated to in-flight LSP requests, and ForgeRelay bounds both per-service semantic concurrency and queued work. Document synchronization is serialized before semantic requests cross the concurrency gate, while independent semantic reads may execute concurrently after that barrier. A server that ignores cancellation keeps its underlying request slot occupied until it actually settles, preventing repeated cancellations from creating an unbounded set of pending JSON-RPC requests.
+
+An unexpected Language-server process exit fails its pending JSON-RPC work immediately instead of waiting for the semantic deadline. ForgeRelay discards that service and retries the current semantic operation at most once. A second consecutive crash for the same Language project/server-definition fingerprint enters a short cooldown before another process may be started; a successful retry clears the crash state. Effective server definitions are fingerprinted, so a changed project/global/built-in definition selects a new service identity on the next code-intelligence resolution and retires only an idle service with the same project root/server id but the old fingerprint. ForgeRelay does not add a recursive config watcher.
+
+Language services are shared by physical Language project identity rather than logical Workspace id, so multiple conversations over the same checkout do not multiply server processes. Idle services are reclaimed after a bounded TTL, and the global service cap evicts the least-recently-used truly idle service; a request that has returned to the Host but whose server ignored cancellation still counts as active until the underlying LSP request settles. Managed-worktree finalization releases idle Language services rooted in that worktree before removing it and refuses finalization while semantic work is still active. Debug runtime telemetry reports only aggregate service/process/request/document/diagnostic/stderr counts and never source contents.

package/dist/capability-registry.js

@@ -79,7 +79,7 @@ export class CapabilityRegistry {
             throw new CapabilityError("invalid_arguments", `Invalid arguments for capability ${name}: ${details}`);
         }
         try {
-            return await definition.run(parsed.data, context);
+            return await definition.run(parsed.data, context, options);
         }
         catch (error) {
             if (error instanceof CapabilityError)
@@ -186,7 +186,7 @@ export function createCapabilityRegistry(dependencies) {
                         available: dependencies.codeIntelligence?.available ?? false,
                         reason: dependencies.codeIntelligence?.unavailableReason,
                     }),
-                    run: async (input, context) => dependencies.codeIntelligence.run(input, context),
+                    run: async (input, context, options) => dependencies.codeIntelligence.run(input, context, options),
                 }]
             : []),
         ...(dependencies.downloadArtifact

package/dist/logger.js

@@ -223,7 +223,17 @@ function formatRuntimeResources(entry) {
     const completed = numberField(entry.processesCompleted) ?? 0;
     const workspaces = numberField(entry.cachedWorkspaces) ?? 0;
     const reviewStates = numberField(entry.reviewStates) ?? 0;
-    return `runtime rss=${rssMb}MB heap=${heapUsedMb}/${heapTotalMb}MB transports=${transports} processes=${running} running/${completed} completed workspaces=${workspaces} review=${reviewStates}`;
+    const languageServices = numberField(entry.languageServices) ?? 0;
+    const languageServicesActive = numberField(entry.languageServicesActive) ?? 0;
+    const languageProcesses = numberField(entry.languageProcessesRunning) ?? 0;
+    const languageRequestsActive = numberField(entry.languageRequestsActive) ?? 0;
+    const languageRequestsQueued = numberField(entry.languageRequestsQueued) ?? 0;
+    const languageDocuments = numberField(entry.languageOpenDocuments) ?? 0;
+    const languageDiagnosticSnapshots = numberField(entry.languageDiagnosticSnapshots) ?? 0;
+    const languageDiagnosticsRetained = numberField(entry.languageDiagnosticsRetained) ?? 0;
+    const languageStderrBytes = numberField(entry.languageStderrBytes) ?? 0;
+    const languageCooldowns = numberField(entry.languageCrashCooldowns) ?? 0;
+    return `runtime rss=${rssMb}MB heap=${heapUsedMb}/${heapTotalMb}MB transports=${transports} processes=${running} running/${completed} completed workspaces=${workspaces} review=${reviewStates} lsp=${languageServices} services/${languageServicesActive} active/${languageProcesses} processes requests=${languageRequestsActive} active/${languageRequestsQueued} queued docs=${languageDocuments} diagnostics=${languageDiagnosticSnapshots} snapshots/${languageDiagnosticsRetained} retained stderr=${languageStderrBytes}B cooldowns=${languageCooldowns}`;
 }
 function bytesToMegabytes(value) {
     return value === undefined ? 0 : Math.round(value / (1024 * 1024));

package/dist/lsp/code-intelligence.js

@@ -3,7 +3,7 @@ import { readFile, realpath } from "node:fs/promises";
 import { basename, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createMessageConnection } from "vscode-jsonrpc/node";
-import { DefinitionRequest, DocumentDiagnosticReportKind, DocumentDiagnosticRequest, DocumentSymbolRequest, DidChangeTextDocumentNotification, DidCloseTextDocumentNotification, DidOpenTextDocumentNotification, ExitNotification, HoverRequest, InitializeRequest, ReferencesRequest, InitializedNotification, MarkupKind, PositionEncodingKind, PublishDiagnosticsNotification, ShutdownRequest, TextDocumentSyncKind, WorkspaceSymbolRequest, } from "vscode-languageserver-protocol";
+import { DefinitionRequest, DocumentDiagnosticReportKind, DocumentDiagnosticRequest, DocumentSymbolRequest, ExitNotification, HoverRequest, InitializeRequest, ReferencesRequest, InitializedNotification, MarkupKind, PositionEncodingKind, PublishDiagnosticsNotification, ShutdownRequest, WorkspaceSymbolRequest, } from "vscode-languageserver-protocol";
 import { LanguageServerConfigurationError, } from "./language-server-config.js";
 import { terminateProcessTree } from "../process-platform.js";
 import { CodeIntelligenceError } from "./code-intelligence-error.js";
@@ -11,8 +11,10 @@ import { DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT } from "./code-intelligence-type
 import { normalizeHoverContents } from "./normalization/hover.js";
 import { normalizeDocumentSymbols, normalizeWorkspaceSymbols, } from "./normalization/symbols.js";
 import { isWithin, locationEntries, normalizeLocations, workspaceDisplayPath, } from "./normalization/locations.js";
-import { lspPositionFromUser, rangeFromLsp, wholeDocumentRange } from "./position-encoding.js";
+import { lspPositionFromUser, rangeFromLsp } from "./position-encoding.js";
 import { DiagnosticSnapshotStore } from "./runtime/diagnostic-snapshots.js";
+import { DocumentSynchronizer } from "./runtime/document-synchronizer.js";
+import { SemanticRequestCoordinator } from "./runtime/semantic-requests.js";
 export { CodeIntelligenceError } from "./code-intelligence-error.js";
 const STDERR_TAIL_BYTES = 64 * 1024;
 export class LanguageService {
@@ -27,8 +29,9 @@ export class LanguageService {
     initializePromise;
     positionEncoding = PositionEncodingKind.UTF16;
     capabilities;
-    documents = new Map();
+    documents;
     diagnosticSnapshots;
+    semanticRequests;
     stderrTail = Buffer.alloc(0);
     closed = false;
     constructor(workspaceRoot, project, policy) {
@@ -36,7 +39,13 @@ export class LanguageService {
         this.project = project;
         this.policy = policy;
         this.key = languageServiceKey(project);
+        this.documents = new DocumentSynchronizer(project.definition);
         this.diagnosticSnapshots = new DiagnosticSnapshotStore(policy.maxDiagnosticDocuments, policy.maxDiagnosticsPerDocument);
+        this.semanticRequests = new SemanticRequestCoordinator({
+            maxConcurrent: policy.maxConcurrentSemanticRequests,
+            maxQueued: policy.maxQueuedSemanticRequests,
+            deadlineMs: policy.requestTimeoutMs,
+        });
     }
     acquire() {
         this.inFlight += 1;
@@ -46,19 +55,37 @@ export class LanguageService {
         this.inFlight = Math.max(0, this.inFlight - 1);
         this.lastUsedAt = Date.now();
     }
-    async definition(input) {
+    get isIdle() {
+        return this.inFlight === 0 &&
+            this.semanticRequests.activeCount === 0 &&
+            this.semanticRequests.queuedCount === 0;
+    }
+    get runtimeStats() {
+        const child = this.child;
+        return {
+            operationInFlight: this.inFlight,
+            semanticRequestsActive: this.semanticRequests.activeCount,
+            semanticRequestsQueued: this.semanticRequests.queuedCount,
+            openDocuments: this.documents.size,
+            diagnosticSnapshots: this.diagnosticSnapshots.size,
+            diagnosticsRetained: this.diagnosticSnapshots.retainedDiagnostics,
+            stderrBytes: this.stderrTail.length,
+            processRunning: Boolean(child && child.exitCode === null && child.signalCode === null),
+        };
+    }
+    async definition(input, signal) {
         try {
             await this.ensureStarted();
             if (!this.capabilities?.definitionProvider) {
                 throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not advertise definition support.`);
             }
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            const document = await this.syncDocument(sourcePath);
+            const document = await this.syncDocumentOrdered(sourcePath);
             const position = lspPositionFromUser(document.text, input.line, input.column, this.positionEncoding);
-            const response = await withTimeout(this.connection.sendRequest(DefinitionRequest.type, {
+            const response = await this.semanticRequests.run(`Definition request for ${input.path}`, signal, (token) => this.connection.sendRequest(DefinitionRequest.type, {
                 textDocument: { uri: document.uri },
                 position,
-            }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `Definition request timed out for ${input.path}.`));
+            }, token));
             const locations = await normalizeLocations(locationEntries(response), this.workspaceRoot, this.positionEncoding);
             return {
                 operation: "definition",
@@ -76,19 +103,19 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
-    async hover(input) {
+    async hover(input, signal) {
         try {
             await this.ensureStarted();
             if (!this.capabilities?.hoverProvider) {
                 throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not advertise hover support.`);
             }
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            const document = await this.syncDocument(sourcePath);
+            const document = await this.syncDocumentOrdered(sourcePath);
             const position = lspPositionFromUser(document.text, input.line, input.column, this.positionEncoding);
-            const response = await withTimeout(this.connection.sendRequest(HoverRequest.type, {
+            const response = await this.semanticRequests.run(`Hover request for ${input.path}`, signal, (token) => this.connection.sendRequest(HoverRequest.type, {
                 textDocument: { uri: document.uri },
                 position,
-            }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `Hover request timed out for ${input.path}.`));
+            }, token));
             const common = {
                 operation: "hover",
                 selectedServer: this.project.definition.id,
@@ -114,20 +141,20 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
-    async references(input) {
+    async references(input, signal) {
         try {
             await this.ensureStarted();
             if (!this.capabilities?.referencesProvider) {
                 throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not advertise references support.`);
             }
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            const document = await this.syncDocument(sourcePath);
+            const document = await this.syncDocumentOrdered(sourcePath);
             const position = lspPositionFromUser(document.text, input.line, input.column, this.positionEncoding);
-            const response = await withTimeout(this.connection.sendRequest(ReferencesRequest.type, {
+            const response = await this.semanticRequests.run(`References request for ${input.path}`, signal, (token) => this.connection.sendRequest(ReferencesRequest.type, {
                 textDocument: { uri: document.uri },
                 position,
                 context: { includeDeclaration: true },
-            }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `References request timed out for ${input.path}.`));
+            }, token));
             const entries = locationEntries(response ?? []);
             const limit = input.limit ?? DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT;
             const selected = entries.slice(0, limit);
@@ -151,17 +178,17 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
-    async documentSymbols(input) {
+    async documentSymbols(input, signal) {
         try {
             await this.ensureStarted();
             if (!this.capabilities?.documentSymbolProvider) {
                 throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not advertise document-symbol support.`);
             }
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            const document = await this.syncDocument(sourcePath);
-            const response = await withTimeout(this.connection.sendRequest(DocumentSymbolRequest.type, {
+            const document = await this.syncDocumentOrdered(sourcePath);
+            const response = await this.semanticRequests.run(`Document-symbol request for ${input.path}`, signal, (token) => this.connection.sendRequest(DocumentSymbolRequest.type, {
                 textDocument: { uri: document.uri },
-            }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `Document-symbol request timed out for ${input.path}.`));
+            }, token));
             const normalized = normalizeDocumentSymbols(response, document.text, this.positionEncoding, input.limit ?? DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT);
             return {
                 operation: "documentSymbols",
@@ -176,15 +203,15 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
-    async workspaceSymbols(input) {
+    async workspaceSymbols(input, signal) {
         try {
             await this.ensureStarted();
             if (!this.capabilities?.workspaceSymbolProvider) {
                 throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not advertise workspace-symbol support.`);
             }
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            await this.syncDocument(sourcePath);
-            const response = await withTimeout(this.connection.sendRequest(WorkspaceSymbolRequest.type, { query: input.query }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `Workspace-symbol request timed out for ${JSON.stringify(input.query)}.`));
+            await this.syncDocumentOrdered(sourcePath);
+            const response = await this.semanticRequests.run(`Workspace-symbol request for ${JSON.stringify(input.query)}`, signal, (token) => this.connection.sendRequest(WorkspaceSymbolRequest.type, { query: input.query }, token));
             const normalized = await normalizeWorkspaceSymbols(response, this.workspaceRoot, this.positionEncoding, input.limit ?? DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT);
             return {
                 operation: "workspaceSymbols",
@@ -199,11 +226,11 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
-    async diagnostics(input) {
+    async diagnostics(input, signal) {
         try {
             await this.ensureStarted();
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            const document = await this.syncDocument(sourcePath);
+            const document = await this.syncDocumentOrdered(sourcePath);
             const limit = input.limit ?? DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT;
             const common = {
                 operation: "diagnostics",
@@ -214,11 +241,11 @@ export class LanguageService {
             const diagnosticProvider = this.capabilities?.diagnosticProvider;
             if (diagnosticProvider) {
                 const previousResultId = this.diagnosticSnapshots.previousPullResultId(document.uri);
-                const response = await withTimeout(this.connection.sendRequest(DocumentDiagnosticRequest.type, {
+                const response = await this.semanticRequests.run(`Diagnostic request for ${input.path}`, signal, (token) => this.connection.sendRequest(DocumentDiagnosticRequest.type, {
                     textDocument: { uri: document.uri },
                     ...(diagnosticProvider.identifier === undefined ? {} : { identifier: diagnosticProvider.identifier }),
                     ...(previousResultId === undefined ? {} : { previousResultId }),
-                }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `Diagnostic request timed out for ${input.path}.`));
+                }, token));
                 if (response.kind === DocumentDiagnosticReportKind.Full) {
                     this.diagnosticSnapshots.capturePull(response.items, document, this.positionEncoding, response.resultId);
                 }
@@ -254,18 +281,7 @@ export class LanguageService {
         const connection = this.connection;
         const child = this.child;
         if (connection) {
-            for (const document of this.documents.values()) {
-                if (!document.openNotified)
-                    continue;
-                try {
-                    await connection.sendNotification(DidCloseTextDocumentNotification.type, {
-                        textDocument: { uri: document.uri },
-                    });
-                }
-                catch {
-                    // The server may already be gone.
-                }
-            }
+            await this.documents.closeAll(connection);
             try {
                 await withTimeout(connection.sendRequest(ShutdownRequest.type), this.policy.shutdownTimeoutMs, () => new Error("Language-server shutdown timed out."));
                 await connection.sendNotification(ExitNotification.type);
@@ -286,6 +302,9 @@ export class LanguageService {
         this.child = undefined;
         this.connection = undefined;
         this.initializePromise = undefined;
+        this.capabilities = undefined;
+        this.positionEncoding = PositionEncodingKind.UTF16;
+        this.stderrTail = Buffer.alloc(0);
     }
     async ensureStarted() {
         if (this.closed) {
@@ -335,6 +354,16 @@ export class LanguageService {
             onExitDuringInitialization = (code, signal) => reject(new CodeIntelligenceError("code.language_service_start_failed", `Language server ${definition.id} exited during initialization (${signal ?? code ?? "unknown"}).${this.stderrSuffix()}`));
             child.once("exit", onExitDuringInitialization);
         });
+        child.on("exit", () => {
+            if (this.closed || this.child !== child)
+                return;
+            try {
+                connection.dispose();
+            }
+            catch {
+                // Pending semantic requests will surface the unexpected process exit.
+            }
+        });
         const rootUri = pathToFileURL(this.project.projectRoot).href;
         const initializeParams = {
             processId: process.pid,
@@ -418,49 +447,8 @@ export class LanguageService {
             this.diagnosticSnapshots.capturePush(params, this.documents.get(params.uri), this.positionEncoding);
         });
     }
-    async syncDocument(sourcePath) {
-        const uri = pathToFileURL(sourcePath).href;
-        const text = await readFile(sourcePath, "utf8");
-        const existing = this.documents.get(uri);
-        const languageId = languageIdForPath(this.project.definition, sourcePath);
-        const synchronization = textDocumentSynchronization(this.capabilities?.textDocumentSync);
-        if (!existing) {
-            const document = { uri, languageId, version: 1, text, openNotified: false };
-            this.documents.set(uri, document);
-            if (synchronization.openClose) {
-                await this.connection.sendNotification(DidOpenTextDocumentNotification.type, {
-                    textDocument: {
-                        uri: document.uri,
-                        languageId: document.languageId,
-                        version: document.version,
-                        text: document.text,
-                    },
-                });
-                document.openNotified = true;
-            }
-            return document;
-        }
-        if (existing.text !== text) {
-            const previousText = existing.text;
-            existing.version += 1;
-            existing.text = text;
-            if (synchronization.change === TextDocumentSyncKind.Full) {
-                await this.connection.sendNotification(DidChangeTextDocumentNotification.type, {
-                    textDocument: { uri, version: existing.version },
-                    contentChanges: [{ text }],
-                });
-            }
-            else if (synchronization.change === TextDocumentSyncKind.Incremental) {
-                await this.connection.sendNotification(DidChangeTextDocumentNotification.type, {
-                    textDocument: { uri, version: existing.version },
-                    contentChanges: [{
-                            range: wholeDocumentRange(previousText, this.positionEncoding),
-                            text,
-                        }],
-                });
-            }
-        }
-        return existing;
+    async syncDocumentOrdered(sourcePath) {
+        return this.documents.sync(sourcePath, this.connection, this.capabilities?.textDocumentSync, this.positionEncoding);
     }
     appendStderr(chunk) {
         this.stderrTail = Buffer.concat([this.stderrTail, chunk]);
@@ -480,22 +468,6 @@ export function languageServiceKey(project) {
         project.definition.fingerprint,
     ]);
 }
-function languageIdForPath(definition, path) {
-    const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
-    return definition.languageIdByExtension[extension] ?? definition.languages[0];
-}
-function textDocumentSynchronization(value) {
-    if (typeof value === "number") {
-        return {
-            openClose: value !== TextDocumentSyncKind.None,
-            change: value,
-        };
-    }
-    return {
-        openClose: value?.openClose === true,
-        change: value?.change ?? TextDocumentSyncKind.None,
-    };
-}
 async function workspaceSourcePath(workspaceRoot, inputPath) {
     const root = resolve(workspaceRoot);
     const path = resolve(root, inputPath);

package/dist/lsp/runtime/diagnostic-snapshots.js

@@ -52,6 +52,14 @@ export class DiagnosticSnapshotStore {
     get size() {
         return this.pushSnapshots.size + this.pullSnapshots.size;
     }
+    get retainedDiagnostics() {
+        let total = 0;
+        for (const snapshot of this.pushSnapshots.values())
+            total += snapshot.diagnostics.length;
+        for (const snapshot of this.pullSnapshots.values())
+            total += snapshot.diagnostics.length;
+        return total;
+    }
     normalizeSnapshot(diagnostics, document, encoding, metadata) {
         return {
             diagnostics: diagnostics

package/dist/lsp/runtime/document-synchronizer.js

@@ -0,0 +1,102 @@
+import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { DidChangeTextDocumentNotification, DidCloseTextDocumentNotification, DidOpenTextDocumentNotification, TextDocumentSyncKind, } from "vscode-languageserver-protocol";
+import { wholeDocumentRange } from "../position-encoding.js";
+export class DocumentSynchronizer {
+    definition;
+    documents = new Map();
+    queue = Promise.resolve();
+    constructor(definition) {
+        this.definition = definition;
+    }
+    get(uri) {
+        return this.documents.get(uri);
+    }
+    get size() {
+        return this.documents.size;
+    }
+    async sync(sourcePath, connection, synchronizationValue, positionEncoding) {
+        const operation = this.queue.then(() => this.syncNow(sourcePath, connection, synchronizationValue, positionEncoding), () => this.syncNow(sourcePath, connection, synchronizationValue, positionEncoding));
+        this.queue = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async closeAll(connection) {
+        await this.queue;
+        for (const document of this.documents.values()) {
+            if (!document.openNotified)
+                continue;
+            try {
+                await connection.sendNotification(DidCloseTextDocumentNotification.type, {
+                    textDocument: { uri: document.uri },
+                });
+            }
+            catch {
+                // The server may already be gone.
+            }
+        }
+    }
+    clear() {
+        this.documents.clear();
+        this.queue = Promise.resolve();
+    }
+    async syncNow(sourcePath, connection, synchronizationValue, positionEncoding) {
+        const uri = pathToFileURL(sourcePath).href;
+        const text = await readFile(sourcePath, "utf8");
+        const existing = this.documents.get(uri);
+        const languageId = languageIdForPath(this.definition, sourcePath);
+        const synchronization = textDocumentSynchronization(synchronizationValue);
+        if (!existing) {
+            const document = { uri, languageId, version: 1, text, openNotified: false };
+            this.documents.set(uri, document);
+            if (synchronization.openClose) {
+                await connection.sendNotification(DidOpenTextDocumentNotification.type, {
+                    textDocument: {
+                        uri: document.uri,
+                        languageId: document.languageId,
+                        version: document.version,
+                        text: document.text,
+                    },
+                });
+                document.openNotified = true;
+            }
+            return document;
+        }
+        if (existing.text !== text) {
+            const previousText = existing.text;
+            existing.version += 1;
+            existing.text = text;
+            if (synchronization.change === TextDocumentSyncKind.Full) {
+                await connection.sendNotification(DidChangeTextDocumentNotification.type, {
+                    textDocument: { uri, version: existing.version },
+                    contentChanges: [{ text }],
+                });
+            }
+            else if (synchronization.change === TextDocumentSyncKind.Incremental) {
+                await connection.sendNotification(DidChangeTextDocumentNotification.type, {
+                    textDocument: { uri, version: existing.version },
+                    contentChanges: [{
+                            range: wholeDocumentRange(previousText, positionEncoding),
+                            text,
+                        }],
+                });
+            }
+        }
+        return existing;
+    }
+}
+function languageIdForPath(definition, path) {
+    const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
+    return definition.languageIdByExtension[extension] ?? definition.languages[0];
+}
+function textDocumentSynchronization(value) {
+    if (typeof value === "number") {
+        return {
+            openClose: value !== TextDocumentSyncKind.None,
+            change: value,
+        };
+    }
+    return {
+        openClose: value?.openClose === true,
+        change: value?.change ?? TextDocumentSyncKind.None,
+    };
+}

package/dist/lsp/runtime/manager.js

@@ -1,5 +1,5 @@
 import { realpath } from "node:fs/promises";
-import { resolve } from "node:path";
+import { resolve, sep } from "node:path";
 import { CodeIntelligenceError, LanguageService, languageServiceKey, } from "../code-intelligence.js";
 import { LanguageServerConfigurationError, resolveLanguageProject, } from "../language-server-config.js";
 const LANGUAGE_SERVICE_IDLE_MS = 10 * 60 * 1_000;
@@ -8,17 +8,25 @@ const MAX_LANGUAGE_SERVICES = 16;
 const LANGUAGE_SERVICE_START_TIMEOUT_MS = 15_000;
 const LANGUAGE_REQUEST_TIMEOUT_MS = 10_000;
 const LANGUAGE_SERVICE_SHUTDOWN_TIMEOUT_MS = 2_000;
+const MAX_CONCURRENT_SEMANTIC_REQUESTS = 4;
+const MAX_QUEUED_SEMANTIC_REQUESTS = 16;
 const MAX_DIAGNOSTIC_DOCUMENTS = 128;
 const MAX_DIAGNOSTICS_PER_DOCUMENT = 1000;
+const LANGUAGE_SERVICE_CRASH_COOLDOWN_MS = 5_000;
 export class CodeIntelligenceManager {
     config;
     services = new Map();
     serviceCreations = new Map();
+    invalidatedServiceKeys = new Set();
+    crashStates = new Map();
+    retiredWorkspaceRoots = new Set();
     serviceCreationQueue = Promise.resolve();
     cleanupTimer;
     policy;
+    crashCooldownMs;
     constructor(config, options = {}) {
         this.config = config;
+        this.crashCooldownMs = positiveInteger(options.crashCooldownMs, LANGUAGE_SERVICE_CRASH_COOLDOWN_MS, "crashCooldownMs");
         this.policy = {
             idleMs: positiveInteger(options.idleMs, LANGUAGE_SERVICE_IDLE_MS, "idleMs"),
             cleanupIntervalMs: positiveInteger(options.cleanupIntervalMs, LANGUAGE_SERVICE_CLEANUP_INTERVAL_MS, "cleanupIntervalMs"),
@@ -26,6 +34,8 @@ export class CodeIntelligenceManager {
             startTimeoutMs: positiveInteger(options.startTimeoutMs, LANGUAGE_SERVICE_START_TIMEOUT_MS, "startTimeoutMs"),
             requestTimeoutMs: positiveInteger(options.requestTimeoutMs, LANGUAGE_REQUEST_TIMEOUT_MS, "requestTimeoutMs"),
             shutdownTimeoutMs: positiveInteger(options.shutdownTimeoutMs, LANGUAGE_SERVICE_SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs"),
+            maxConcurrentSemanticRequests: positiveInteger(options.maxConcurrentSemanticRequests, MAX_CONCURRENT_SEMANTIC_REQUESTS, "maxConcurrentSemanticRequests"),
+            maxQueuedSemanticRequests: positiveInteger(options.maxQueuedSemanticRequests, MAX_QUEUED_SEMANTIC_REQUESTS, "maxQueuedSemanticRequests"),
             maxDiagnosticDocuments: positiveInteger(options.maxDiagnosticDocuments, MAX_DIAGNOSTIC_DOCUMENTS, "maxDiagnosticDocuments"),
             maxDiagnosticsPerDocument: positiveInteger(options.maxDiagnosticsPerDocument, MAX_DIAGNOSTICS_PER_DOCUMENT, "maxDiagnosticsPerDocument"),
         };
@@ -34,11 +44,12 @@ export class CodeIntelligenceManager {
         }, this.policy.cleanupIntervalMs);
         this.cleanupTimer.unref();
     }
-    async run(workspaceRoot, input) {
+    async run(workspaceRoot, input, options = {}) {
         let project;
         let canonicalWorkspaceRoot;
         try {
             canonicalWorkspaceRoot = await realpath(resolve(workspaceRoot));
+            this.assertWorkspaceRootAvailable(canonicalWorkspaceRoot);
             project = await resolveLanguageProject({
                 workspaceRoot: canonicalWorkspaceRoot,
                 sourcePath: input.path,
@@ -51,26 +62,42 @@ export class CodeIntelligenceManager {
             }
             throw error;
         }
-        const service = await this.acquireService(canonicalWorkspaceRoot, project);
-        try {
-            switch (input.operation) {
-                case "definition":
-                    return await service.definition(input);
-                case "hover":
-                    return await service.hover(input);
-                case "references":
-                    return await service.references(input);
-                case "documentSymbols":
-                    return await service.documentSymbols(input);
-                case "workspaceSymbols":
-                    return await service.workspaceSymbols(input);
-                case "diagnostics":
-                    return await service.diagnostics(input);
+        await this.invalidateChangedServices(project);
+        const identity = languageServiceKey(project);
+        this.assertNotCoolingDown(identity, project);
+        let lastCrash;
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            this.assertWorkspaceRootAvailable(canonicalWorkspaceRoot);
+            const service = await this.acquireService(canonicalWorkspaceRoot, project);
+            let crashed = false;
+            try {
+                const result = await this.executeOperation(service, input, options.signal);
+                this.crashStates.delete(identity);
+                return result;
+            }
+            catch (error) {
+                if (!(error instanceof CodeIntelligenceError) || error.code !== "code.server_crashed") {
+                    throw error;
+                }
+                crashed = true;
+                lastCrash = error;
+            }
+            finally {
+                await this.releaseService(service);
+            }
+            if (crashed) {
+                await this.discardService(service);
+                const failures = (this.crashStates.get(identity)?.failures ?? 0) + 1;
+                if (attempt === 0) {
+                    this.crashStates.set(identity, { failures, cooldownUntil: 0 });
+                    continue;
+                }
+                const cooldownUntil = Date.now() + this.crashCooldownMs;
+                this.crashStates.set(identity, { failures, cooldownUntil });
+                throw new CodeIntelligenceError("code.language_service_cooldown", `Language server ${project.definition.id} crashed repeatedly; retry after ${this.crashCooldownMs}ms. Last error: ${lastCrash.message}`);
             }
         }
-        finally {
-            service.release();
-        }
+        throw lastCrash ?? new CodeIntelligenceError("code.server_crashed", `Language server ${project.definition.id} failed without a recoverable result.`);
     }
     async shutdown() {
         clearInterval(this.cleanupTimer);
@@ -78,11 +105,150 @@ export class CodeIntelligenceManager {
         this.serviceCreations.clear();
         const services = [...this.services.values()];
         this.services.clear();
+        this.invalidatedServiceKeys.clear();
+        this.crashStates.clear();
+        this.retiredWorkspaceRoots.clear();
         await Promise.allSettled(services.map((service) => service.shutdown()));
     }
     get size() {
         return this.services.size;
     }
+    stats() {
+        const services = [...this.services.values()];
+        const now = Date.now();
+        return services.reduce((stats, service) => {
+            const serviceStats = service.runtimeStats;
+            stats.servicesActive += service.isIdle ? 0 : 1;
+            stats.servicesIdle += service.isIdle ? 1 : 0;
+            stats.processesRunning += serviceStats.processRunning ? 1 : 0;
+            stats.operationsInFlight += serviceStats.operationInFlight;
+            stats.semanticRequestsActive += serviceStats.semanticRequestsActive;
+            stats.semanticRequestsQueued += serviceStats.semanticRequestsQueued;
+            stats.openDocuments += serviceStats.openDocuments;
+            stats.diagnosticSnapshots += serviceStats.diagnosticSnapshots;
+            stats.diagnosticsRetained += serviceStats.diagnosticsRetained;
+            stats.stderrBytes += serviceStats.stderrBytes;
+            return stats;
+        }, {
+            servicesTotal: services.length,
+            servicesActive: 0,
+            servicesIdle: 0,
+            processesRunning: 0,
+            operationsInFlight: 0,
+            semanticRequestsActive: 0,
+            semanticRequestsQueued: 0,
+            openDocuments: 0,
+            diagnosticSnapshots: 0,
+            diagnosticsRetained: 0,
+            stderrBytes: 0,
+            pendingCreations: this.serviceCreations.size,
+            crashCooldowns: [...this.crashStates.values()].filter((state) => state.cooldownUntil > now).length,
+            invalidatedServices: this.invalidatedServiceKeys.size,
+            retiredWorkspaceRoots: this.retiredWorkspaceRoots.size,
+        });
+    }
+    async retireWorkspaceRoot(workspaceRoot) {
+        const canonicalRoot = await realpath(resolve(workspaceRoot));
+        this.retiredWorkspaceRoots.add(canonicalRoot);
+        await Promise.allSettled(this.serviceCreations.values());
+        const matching = [...this.services.entries()].filter(([, service]) => resolve(service.workspaceRoot) === canonicalRoot);
+        const active = matching.filter(([, service]) => !service.isIdle);
+        if (active.length > 0) {
+            this.retiredWorkspaceRoots.delete(canonicalRoot);
+            throw new CodeIntelligenceError("code.language_service_busy", `Cannot finalize Workspace ${canonicalRoot} while ${active.length} Language service request(s) are still active.`);
+        }
+        let releasedServices = 0;
+        for (const [key, service] of matching) {
+            if (this.services.get(key) === service)
+                this.services.delete(key);
+            this.invalidatedServiceKeys.delete(key);
+            this.crashStates.delete(key);
+            await service.shutdown();
+            releasedServices += 1;
+        }
+        this.clearIdentityStateForWorkspaceRoot(canonicalRoot);
+        return { root: canonicalRoot, releasedServices };
+    }
+    restoreWorkspaceRoot(root) {
+        this.retiredWorkspaceRoots.delete(resolve(root));
+    }
+    assertWorkspaceRootAvailable(workspaceRoot) {
+        if (!this.retiredWorkspaceRoots.has(resolve(workspaceRoot)))
+            return;
+        throw new CodeIntelligenceError("code.language_service_unavailable", "Code intelligence is unavailable because this managed-worktree Workspace is being finalized.");
+    }
+    clearIdentityStateForWorkspaceRoot(workspaceRoot) {
+        for (const key of [...this.crashStates.keys()]) {
+            if (identityBelongsToWorkspaceRoot(key, workspaceRoot))
+                this.crashStates.delete(key);
+        }
+        for (const key of [...this.invalidatedServiceKeys]) {
+            if (identityBelongsToWorkspaceRoot(key, workspaceRoot))
+                this.invalidatedServiceKeys.delete(key);
+        }
+    }
+    async executeOperation(service, input, signal) {
+        switch (input.operation) {
+            case "definition":
+                return service.definition(input, signal);
+            case "hover":
+                return service.hover(input, signal);
+            case "references":
+                return service.references(input, signal);
+            case "documentSymbols":
+                return service.documentSymbols(input, signal);
+            case "workspaceSymbols":
+                return service.workspaceSymbols(input, signal);
+            case "diagnostics":
+                return service.diagnostics(input, signal);
+        }
+    }
+    assertNotCoolingDown(identity, project) {
+        const state = this.crashStates.get(identity);
+        if (!state?.cooldownUntil)
+            return;
+        const remaining = state.cooldownUntil - Date.now();
+        if (remaining <= 0) {
+            this.crashStates.delete(identity);
+            return;
+        }
+        throw new CodeIntelligenceError("code.language_service_cooldown", `Language server ${project.definition.id} is cooling down after repeated crashes; retry in ${remaining}ms.`);
+    }
+    async invalidateChangedServices(project) {
+        const root = resolve(project.projectRoot);
+        const invalidated = [];
+        for (const [key, service] of this.services) {
+            if (resolve(service.project.projectRoot) === root &&
+                service.project.definition.id === project.definition.id &&
+                service.project.definition.fingerprint !== project.definition.fingerprint) {
+                this.invalidatedServiceKeys.add(key);
+                this.crashStates.delete(key);
+                if (service.isIdle)
+                    invalidated.push([key, service]);
+            }
+        }
+        for (const [key, service] of invalidated) {
+            if (this.services.get(key) === service)
+                this.services.delete(key);
+            this.invalidatedServiceKeys.delete(key);
+            await service.shutdown();
+        }
+    }
+    async releaseService(service) {
+        service.release();
+        if (!this.invalidatedServiceKeys.has(service.key) || !service.isIdle)
+            return;
+        if (this.services.get(service.key) === service)
+            this.services.delete(service.key);
+        this.invalidatedServiceKeys.delete(service.key);
+        await service.shutdown();
+    }
+    async discardService(service) {
+        if (this.services.get(service.key) === service)
+            this.services.delete(service.key);
+        this.invalidatedServiceKeys.delete(service.key);
+        await service.shutdown();
+    }
     async acquireService(workspaceRoot, project) {
         const key = languageServiceKey(project);
         const existing = this.services.get(key);
@@ -133,7 +299,7 @@ export class CodeIntelligenceManager {
         }
     }
     async closeIdle(now = Date.now()) {
-        const stale = [...this.services.entries()].filter(([, service]) => service.inFlight === 0 && now - service.lastUsedAt >= this.policy.idleMs);
+        const stale = [...this.services.entries()].filter(([, service]) => service.isIdle && now - service.lastUsedAt >= this.policy.idleMs);
         for (const [key, service] of stale) {
             this.services.delete(key);
             await service.shutdown();
@@ -143,7 +309,7 @@ export class CodeIntelligenceManager {
         if (this.services.size < this.policy.maxServices)
             return;
         const idle = [...this.services.entries()]
-            .filter(([, service]) => service.inFlight === 0)
+            .filter(([, service]) => service.isIdle)
             .sort((left, right) => left[1].lastUsedAt - right[1].lastUsedAt);
         const candidate = idle[0];
         if (!candidate) {
@@ -153,6 +319,21 @@ export class CodeIntelligenceManager {
         await candidate[1].shutdown();
     }
 }
+function identityBelongsToWorkspaceRoot(identity, workspaceRoot) {
+    try {
+        const parsed = JSON.parse(identity);
+        const projectRoot = Array.isArray(parsed) && typeof parsed[0] === "string"
+            ? resolve(parsed[0])
+            : undefined;
+        if (!projectRoot)
+            return false;
+        const root = resolve(workspaceRoot);
+        return projectRoot === root || projectRoot.startsWith(`${root}${sep}`);
+    }
+    catch {
+        return false;
+    }
+}
 function positiveInteger(value, fallback, label) {
     const resolvedValue = value ?? fallback;
     if (!Number.isInteger(resolvedValue) || resolvedValue < 1) {

package/dist/lsp/runtime/semantic-requests.js

@@ -0,0 +1,116 @@
+import { CancellationTokenSource } from "vscode-jsonrpc";
+import { CodeIntelligenceError } from "../code-intelligence-error.js";
+export class SemanticRequestCoordinator {
+    options;
+    active = 0;
+    queue = [];
+    constructor(options) {
+        this.options = options;
+    }
+    async run(label, signal, operation) {
+        const startedAt = Date.now();
+        await this.acquire(label, signal, startedAt);
+        const source = new CancellationTokenSource();
+        let settledForCaller = false;
+        let timeout;
+        let onAbort;
+        const cancellation = new Promise((_resolve, reject) => {
+            const rejectOnce = (error) => {
+                if (settledForCaller)
+                    return;
+                settledForCaller = true;
+                try {
+                    source.cancel();
+                }
+                catch {
+                    // The Language-server connection may already have closed or crashed.
+                }
+                reject(error);
+            };
+            const remaining = Math.max(1, this.options.deadlineMs - (Date.now() - startedAt));
+            timeout = setTimeout(() => rejectOnce(new CodeIntelligenceError("code.request_timeout", `${label} exceeded the ${this.options.deadlineMs}ms semantic request deadline.`)), remaining);
+            timeout.unref();
+            if (signal) {
+                onAbort = () => rejectOnce(new CodeIntelligenceError("code.request_cancelled", `${label} was cancelled by the Host.`));
+                if (signal.aborted)
+                    onAbort();
+                else
+                    signal.addEventListener("abort", onAbort, { once: true });
+            }
+        });
+        const underlying = operation(source.token);
+        underlying.finally(() => {
+            source.dispose();
+            this.release();
+        }).catch(() => undefined);
+        try {
+            const value = await Promise.race([underlying, cancellation]);
+            settledForCaller = true;
+            return value;
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+            if (signal && onAbort)
+                signal.removeEventListener("abort", onAbort);
+        }
+    }
+    get activeCount() {
+        return this.active;
+    }
+    get queuedCount() {
+        return this.queue.length;
+    }
+    async acquire(label, signal, startedAt) {
+        if (signal?.aborted) {
+            throw new CodeIntelligenceError("code.request_cancelled", `${label} was cancelled by the Host.`);
+        }
+        if (this.active < this.options.maxConcurrent) {
+            this.active += 1;
+            return;
+        }
+        if (this.queue.length >= this.options.maxQueued) {
+            throw new CodeIntelligenceError("code.request_capacity", `Semantic request queue capacity reached (${this.options.maxQueued}) for this Language service.`);
+        }
+        await new Promise((resolve, reject) => {
+            const waiter = { resolve, reject, signal };
+            const remaining = Math.max(1, this.options.deadlineMs - (Date.now() - startedAt));
+            const remove = () => {
+                const index = this.queue.indexOf(waiter);
+                if (index >= 0)
+                    this.queue.splice(index, 1);
+            };
+            waiter.timer = setTimeout(() => {
+                remove();
+                reject(new CodeIntelligenceError("code.request_timeout", `${label} exceeded the ${this.options.deadlineMs}ms semantic request deadline while queued.`));
+            }, remaining);
+            waiter.timer.unref();
+            if (signal) {
+                waiter.onAbort = () => {
+                    remove();
+                    if (waiter.timer)
+                        clearTimeout(waiter.timer);
+                    reject(new CodeIntelligenceError("code.request_cancelled", `${label} was cancelled by the Host.`));
+                };
+                signal.addEventListener("abort", waiter.onAbort, { once: true });
+            }
+            this.queue.push(waiter);
+        });
+    }
+    release() {
+        this.active = Math.max(0, this.active - 1);
+        while (this.queue.length > 0 && this.active < this.options.maxConcurrent) {
+            const waiter = this.queue.shift();
+            if (waiter.timer)
+                clearTimeout(waiter.timer);
+            if (waiter.signal && waiter.onAbort)
+                waiter.signal.removeEventListener("abort", waiter.onAbort);
+            if (waiter.signal?.aborted) {
+                waiter.reject(new CodeIntelligenceError("code.request_cancelled", "Semantic request was cancelled by the Host."));
+                continue;
+            }
+            this.active += 1;
+            waiter.resolve();
+        }
+    }
+}

package/dist/lsp/test-support/server-fixture.js

@@ -53,7 +53,7 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
         await close();
         await rm(root, { recursive: true, force: true });
     });
-    return { client, project, close };
+    return { client, project, codeIntelligence, close };
 }
 export async function callOpen(client, path, conversationScopeId) {
     return client.callTool({

package/dist/server.js

@@ -755,10 +755,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         inspectHooks: (workspaceRoot) => checkHookConfiguration(workspaceRoot, config.hooks),
         codeIntelligence: {
             available: true,
-            run: async (input, context) => {
+            run: async (input, context, options) => {
                 try {
                     return {
-                        value: await codeIntelligence.run(context.workspaceRoot, input),
+                        value: await codeIntelligence.run(context.workspaceRoot, input, { signal: options.signal }),
                     };
                 }
                 catch (error) {
@@ -1254,7 +1254,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             idempotentHint: false,
             openWorldHint: true,
         },
-    }, async ({ workspaceId, name, action, arguments: capabilityArguments, file }) => {
+    }, async ({ workspaceId, name, action, arguments: capabilityArguments, file }, extra) => {
         const workspace = workspaces.getWorkspace(workspaceId);
         let changedPaths = [];
         return runToolWithHooks(hooks, {
@@ -1289,7 +1289,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         });
                         return result;
                     }
-                    const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, capabilityContextFor(workspace), { nativeFile: file });
+                    const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, capabilityContextFor(workspace), { nativeFile: file, signal: extra.signal });
                     changedPaths = execution.changedPaths ?? [];
                     const result = {
                         content: [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
@@ -1389,7 +1389,14 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         throw new Error(`Cannot close this worktree-backed workspace while logical workspace processes are still running or awaiting completion delivery: ${busyWorkspaceIds.join(", ")}.`);
                     }
                     const startedAt = performance.now();
-                    const closed = await workspaces.closeWorktree(workspaceId, commitMessage);
+                    const retirement = await codeIntelligence.retireWorkspaceRoot(workspace.root);
+                    let closed;
+                    try {
+                        closed = await workspaces.closeWorktree(workspaceId, commitMessage);
+                    }
+                    finally {
+                        codeIntelligence.restoreWorkspaceRoot(retirement.root);
+                    }
                     await Promise.all(physicalWorkspaceIds.map((id) => reviewCheckpoints.releaseWorkspace(id)));
                     const result = [
                         `Closed managed-worktree-backed workspace ${workspaceId}.`,
@@ -2161,6 +2168,7 @@ export function createServer(config = loadConfig(), options = {}) {
     const logRuntimeResources = () => {
         const memory = process.memoryUsage();
         const processStats = processSessions.stats();
+        const codeStats = codeIntelligence.stats();
         logEvent(config.logging, "debug", "runtime_resources", {
             rssBytes: memory.rss,
             heapUsedBytes: memory.heapUsed,
@@ -2173,7 +2181,20 @@ export function createServer(config = loadConfig(), options = {}) {
             processesCompleted: processStats.completed,
             cachedWorkspaces: workspaces.cachedWorkspaceCount,
             reviewStates: reviewCheckpoints.stateCount,
-            languageServices: codeIntelligence.size,
+            languageServices: codeStats.servicesTotal,
+            languageServicesActive: codeStats.servicesActive,
+            languageProcessesRunning: codeStats.processesRunning,
+            languageOperationsInFlight: codeStats.operationsInFlight,
+            languageRequestsActive: codeStats.semanticRequestsActive,
+            languageRequestsQueued: codeStats.semanticRequestsQueued,
+            languageOpenDocuments: codeStats.openDocuments,
+            languageDiagnosticSnapshots: codeStats.diagnosticSnapshots,
+            languageDiagnosticsRetained: codeStats.diagnosticsRetained,
+            languageStderrBytes: codeStats.stderrBytes,
+            languagePendingCreations: codeStats.pendingCreations,
+            languageCrashCooldowns: codeStats.crashCooldowns,
+            languageInvalidatedServices: codeStats.invalidatedServices,
+            languageRetiredWorkspaceRoots: codeStats.retiredWorkspaceRoots,
         });
     };
     const transportCleanupTimer = setInterval(() => {

package/docs/configuration.md

@@ -154,7 +154,7 @@ force a Host to invalidate its cached schema.
 ### LSP code intelligence
 
 ForgeRelay advertises `code.intelligence` through the Capability Gateway; it does
-not add language-specific top-level MCP tools. ForgeRelay 0.4.4 supports
+not add language-specific top-level MCP tools. ForgeRelay 0.4.5 supports
 `definition`, `hover`, `references`, `documentSymbols`, `workspaceSymbols`, and
 `diagnostics`.
 Position-based operations accept the same workspace-relative source position. Hover
@@ -175,6 +175,24 @@ and the real `total` when the complete Language-server response makes it known.
 dependencies: ForgeRelay may discover an executable already installed on the
 machine, but it never downloads or installs one automatically.
 
+ForgeRelay 0.4.5 hardens this shared Language-service runtime. Semantic requests
+have one internal bounded deadline, Host cancellation propagates to LSP cancellation,
+and each service has finite concurrent and queued request budgets rather than
+Agent-configurable timeouts. An unexpected server crash is retried at most once;
+repeated crashes enter a short cooldown. Effective server-definition fingerprints
+invalidate only the affected project/service on the next resolution without adding
+a recursive filesystem watcher.
+
+Language services are keyed by physical Language project identity, so logical
+workspaces over the same checkout reuse one process. Truly idle services are
+reclaimed after a bounded TTL and the global service cap evicts the least-recently-
+used safe idle service. A server request that ignores cancellation still counts as
+active until the underlying JSON-RPC request settles. Managed-worktree finalization
+releases services rooted in that worktree before removal and refuses finalization
+while semantic work is active. Debug `runtime_resources` telemetry includes only
+aggregate Language-service/process/request/document/diagnostic/stderr counts; it
+does not log source contents or source paths.
+
 Effective Language-server definitions resolve in this order:
 
 1. project configuration in `.forgerelay/language-servers.json`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",
@@ -42,7 +42,7 @@
     "debug:accept": "node scripts/debug/accept.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
+    "test": "tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "release:check": "node scripts/release-version.mjs check",
     "release:tag-check": "node scripts/release-version.mjs tag",