@mrclrchtr/supi-lsp 10.0.0 → 11.0.1

package/src/client/client-diagnostic-host.ts

@@ -1,3 +1,4 @@
+import type { CFamilyFileAssociationResolver } from "@mrclrchtr/supi-code-runtime/api";
 import type { DiagnosticRequestAdapter } from "./client-diagnostic-request.ts";
 import type { NormalizedDocumentSync } from "./client-document-sync.ts";
 
@@ -7,6 +8,8 @@ export interface ClientDiagnosticsHost {
   server: string;
   /** Absolute workspace root, for debug-telemetry identity. */
   cwd?: string;
+  /** Immutable workspace association snapshot used for didOpen document IDs. */
+  fileAssociations?: CFamilyFileAssociationResolver;
   isOperational(): boolean;
   /** Native pull and server-specific request evidence share this priority adapter. */
   diagnosticRequestAdapter: DiagnosticRequestAdapter;

package/src/client/client-diagnostics.ts

@@ -51,6 +51,7 @@ import { SemanticInputRequestRetryGuard } from "./client-request-enrollment.ts";
 import {
   SemanticInputBarrier,
   type SemanticInputDocument,
+  type SemanticInputRevision,
   type SemanticInputSnapshot,
   type SemanticInputUpdate,
 } from "./client-semantic-input-barrier.ts";
@@ -156,10 +157,10 @@ export class ClientDiagnostics {
 
   /** Fail closed when a semantic request observes a changed input generation. */
   assertSemanticInputsCurrent(
-    snapshot: SemanticInputSnapshot,
+    snapshot: SemanticInputRevision,
     control?: CodeRequestControl,
     contentOverrides?: ReadonlyMap<string, string>,
-  ): Promise<void> {
+  ): Promise<SemanticInputSnapshot> {
     throwIfCodeRequestInterrupted(control);
     return this.#inputBarrier.assertCurrent(snapshot, control, contentOverrides);
   }
@@ -168,6 +169,7 @@ export class ClientDiagnostics {
     return Array.from(this.#openDocs, ([uri, document]) => ({
       uri,
       filePath: uriToFile(uri),
+      version: document.version,
       content: document.content,
       contentFingerprint: document.contentFingerprint,
     }));
@@ -293,7 +295,7 @@ export class ClientDiagnostics {
     this.#cancelDiagnosticRequest(uri);
     this.#advanceInputRevision(false, false, "enrollment");
 
-    const languageId = detectLanguageId(filePath);
+    const languageId = detectLanguageId(filePath, this.host.fileAssociations);
     this.#waiters.cancelSettle();
     // A didOpen is a synchronization: pushes the server sends after it are
     // responses to the open and can become fresh evidence (ADR 0020).
@@ -797,7 +799,7 @@ export class ClientDiagnostics {
 
   async #verifyDiagnosticInputs(options: {
     result: CodeQueryResult<Diagnostic[]>;
-    snapshot: SemanticInputSnapshot;
+    snapshot: SemanticInputRevision;
     control: CodeRequestControl | undefined;
     contentOverrides: ReadonlyMap<string, string> | undefined;
     uri: string;

package/src/client/client-request-enrollment.ts

@@ -3,30 +3,61 @@ import {
   type SemanticInputSynchronizationError,
 } from "./client-semantic-input-errors.ts";
 
-const MAX_REQUEST_ENROLLMENT_RETRIES = 1;
+const MAX_REQUEST_RETRIES = 1;
+const CONTENT_MODIFIED_ERROR_CODE = -32_801;
 
-/** A request-level enrollment retry decision owned by one request attempt. */
-export type RequestEnrollmentRetryDecision =
-  | { readonly kind: "retry" }
-  | { readonly kind: "stop"; readonly error: unknown };
+/** Reason that permits one request retry. */
+export type SemanticInputRequestRetryReason = "content-modified" | "enrollment";
+
+/** A request-level retry decision owned by one attempt. */
+export type SemanticInputRequestRetryDecision =
+  | { readonly kind: "retry"; readonly reason: SemanticInputRequestRetryReason }
+  | {
+      readonly kind: "stop";
+      readonly error: unknown;
+      readonly reason?: SemanticInputRequestRetryReason;
+    };
 
 /** Look up the current input change after a failed request revision. */
 export type SemanticInputChangeLookup = (
   revision: number,
 ) => SemanticInputSynchronizationError | undefined;
 
+/** Optional request retry policies. ContentModified retries stay off by default. */
+export interface SemanticInputRequestRetryPolicy {
+  readonly retryContentModified?: boolean;
+  /** Retain a verified revision across document enrollment and a follow-up request. */
+  readonly inputRevision?: number;
+}
+
+function isContentModifiedError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: unknown }).code === CONTENT_MODIFIED_ERROR_CODE
+  );
+}
+
 /**
- * Keep one semantic or diagnostic request's enrollment retry policy cohesive.
+ * Keep one LSP request's input retry policy in one place.
  *
- * Synchronization passes have their own rejoin budget. This guard only owns
- * the request-level budget and the first failed revision used to classify
- * later changes.
+ * Synchronization passes have their own rejoin budget. This guard owns one
+ * shared request retry budget and a protected revision used to classify later
+ * changes. A caller can retain an earlier verified revision across enrollment.
+ * Protocol retries are disabled unless the caller opts in.
  */
 export class SemanticInputRequestRetryGuard {
   #requestRetries = 0;
-  #firstFailedRevision: number | undefined;
+  #protectedRevision: number | undefined;
+  #retryReason: SemanticInputRequestRetryReason | undefined;
 
-  constructor(private readonly currentChangeSince: SemanticInputChangeLookup) {}
+  constructor(
+    private readonly currentChangeSince: SemanticInputChangeLookup,
+    private readonly policy: SemanticInputRequestRetryPolicy = {},
+  ) {
+    this.#protectedRevision = policy.inputRevision;
+  }
 
   /** Number of request-level retries permitted for this request so far. */
   get retryCount(): number {
@@ -38,6 +69,11 @@ export class SemanticInputRequestRetryGuard {
     return this.#requestRetries > 0;
   }
 
+  /** Cause of the retry already used by this request, if any. */
+  get retryReason(): SemanticInputRequestRetryReason | undefined {
+    return this.#retryReason;
+  }
+
   /** Throw the current non-enrollment cause when it blocks a retry. */
   assertCurrent(): void {
     const blockingChange = this.#getBlockingChange();
@@ -45,31 +81,39 @@ export class SemanticInputRequestRetryGuard {
   }
 
   /** Classify one failed attempt and decide whether it may be retried. */
-  decide(error: unknown, inputRevision: number | undefined): RequestEnrollmentRetryDecision {
-    if (!isSemanticInputEnrollmentError(error)) {
-      return { kind: "stop", error };
-    }
+  decide(error: unknown, inputRevision: number | undefined): SemanticInputRequestRetryDecision {
+    const reason = this.#getRetryReason(error);
+    if (!reason) return { kind: "stop", error };
 
-    if (this.#firstFailedRevision !== undefined) {
+    if (this.#protectedRevision !== undefined) {
       const blockingChange = this.#getBlockingChange();
       if (blockingChange) return { kind: "stop", error: blockingChange };
     }
     if (inputRevision === undefined) return { kind: "stop", error };
 
-    this.#firstFailedRevision ??= inputRevision;
+    this.#protectedRevision ??= inputRevision;
     const blockingChange = this.#getBlockingChange();
     if (blockingChange) return { kind: "stop", error: blockingChange };
-    if (this.#requestRetries >= MAX_REQUEST_ENROLLMENT_RETRIES) {
-      return { kind: "stop", error };
+    if (this.#requestRetries >= MAX_REQUEST_RETRIES) {
+      return { kind: "stop", error, reason };
     }
 
     this.#requestRetries++;
-    return { kind: "retry" };
+    this.#retryReason ??= reason;
+    return { kind: "retry", reason };
+  }
+
+  #getRetryReason(error: unknown): SemanticInputRequestRetryReason | undefined {
+    if (isSemanticInputEnrollmentError(error)) return "enrollment";
+    if (this.policy.retryContentModified && isContentModifiedError(error)) {
+      return "content-modified";
+    }
+    return undefined;
   }
 
   #getBlockingChange(): SemanticInputSynchronizationError | undefined {
-    if (this.#firstFailedRevision === undefined) return undefined;
-    const currentChange = this.currentChangeSince(this.#firstFailedRevision);
+    if (this.#protectedRevision === undefined) return undefined;
+    const currentChange = this.currentChangeSince(this.#protectedRevision);
     return currentChange?.changeKind === "enrollment" ? undefined : currentChange;
   }
 }

package/src/client/client-semantic-input-barrier.ts

@@ -21,10 +21,19 @@ const DEFAULT_MAX_CONCURRENT_READS = 16;
 export interface SemanticInputDocument {
   readonly uri: string;
   readonly filePath: string;
+  readonly version: number;
   readonly content: string;
   readonly contentFingerprint: string;
 }
 
+/** One open buffer and disk fingerprint verified by an input synchronization pass. */
+export interface SemanticInputDocumentSnapshot {
+  readonly filePath: string;
+  readonly version: number;
+  readonly contentFingerprint: string;
+  readonly diskContentFingerprint: string;
+}
+
 /** One open document update selected by the barrier after a full read. */
 export interface SemanticInputUpdate {
   readonly document: SemanticInputDocument;
@@ -48,11 +57,16 @@ export interface SemanticInputBarrierOptions {
   readonly readFile?: SemanticInputFileReader;
 }
 
-/** Revision token returned by one completed input synchronization pass. */
-export interface SemanticInputSnapshot {
+/** Revision token used to check one semantic input generation. */
+export interface SemanticInputRevision {
   readonly revision: number;
 }
 
+/** Verified inputs returned by one complete synchronization pass. */
+export interface SemanticInputSnapshot extends SemanticInputRevision {
+  readonly documents: readonly SemanticInputDocumentSnapshot[];
+}
+
 interface OpenDocumentRead {
   readonly document: SemanticInputDocument;
   readonly result:
@@ -150,10 +164,10 @@ export class SemanticInputBarrier {
 
   /** Recheck the full input set after a semantic request completes. */
   async assertCurrent(
-    snapshot: SemanticInputSnapshot,
+    snapshot: SemanticInputRevision,
     control?: CodeRequestControl,
     contentOverrides?: ReadonlyMap<string, string>,
-  ): Promise<void> {
+  ): Promise<SemanticInputSnapshot> {
     if (!this.#host.isOperational()) {
       throw new Error("Semantic input synchronization is unavailable because the client stopped.");
     }
@@ -176,6 +190,7 @@ export class SemanticInputBarrier {
         )
       );
     }
+    return current;
   }
 
   /** Return the current typed input change after a revision, when present. */
@@ -305,7 +320,24 @@ export class SemanticInputBarrier {
     // resulting generation as owned by this completed pass so a late caller
     // can join it instead of starting a redundant read pass.
     pending.generation = this.#revision;
-    return { revision: this.#revision };
+    const currentDocuments = this.#host.getOpenDocuments();
+    const diskFingerprints = new Map(plan.observedDiskFingerprints);
+    return {
+      revision: this.#revision,
+      documents: currentDocuments.flatMap((document) => {
+        const diskContentFingerprint = diskFingerprints.get(document.uri);
+        return diskContentFingerprint === undefined
+          ? []
+          : [
+              {
+                filePath: document.filePath,
+                version: document.version,
+                contentFingerprint: document.contentFingerprint,
+                diskContentFingerprint,
+              },
+            ];
+      }),
+    };
   }
 
   #assertPendingCanRun(pending: PendingSynchronization): void {

package/src/client/client.ts

@@ -5,6 +5,7 @@
 import { type ChildProcess, execSync, spawn } from "node:child_process";
 import * as path from "node:path";
 import {
+  type CFamilyFileAssociationResolver,
   type CodeQueryResult,
   type CodeRequestControl,
   completedCodeQuery,
@@ -69,11 +70,15 @@ import { createTypeScriptDiagnosticRequestAdapter } from "./client-diagnostic-ty
 import { ClientDiagnostics } from "./client-diagnostics.ts";
 import type { ClientDiagnosticSnapshot, DiagnosticEntry } from "./client-document-state.ts";
 import { type NormalizedDocumentSync, normalizeDocumentSync } from "./client-document-sync.ts";
-import { SemanticInputRequestRetryGuard } from "./client-request-enrollment.ts";
 import {
-  isSemanticInputEnrollmentError,
-  SemanticInputSynchronizationError,
-} from "./client-semantic-input-errors.ts";
+  SemanticInputRequestRetryGuard,
+  type SemanticInputRequestRetryReason,
+} from "./client-request-enrollment.ts";
+import type {
+  SemanticInputDocumentSnapshot,
+  SemanticInputSnapshot,
+} from "./client-semantic-input-barrier.ts";
+import { SemanticInputSynchronizationError } from "./client-semantic-input-errors.ts";
 import { JsonRpcClient, JsonRpcRequestError } from "./transport.ts";
 
 const SHUTDOWN_TIMEOUT_MS = 5_000;
@@ -87,7 +92,15 @@ interface SemanticRequestAttemptState {
 
 interface RefactorTransaction {
   rpc: JsonRpcClient;
-  assertCurrent: () => Promise<void>;
+  assertCurrent: () => Promise<SemanticInputSnapshot>;
+}
+
+export interface RenameDetailedWithSnapshotsResult {
+  readonly result: CodeQueryResult<WorkspaceEdit | null>;
+  /** Verified input revision retained when a rename needs document enrollment. */
+  readonly inputRevision?: number;
+  /** Exact documents synchronized before and rechecked after this request. */
+  readonly documentSnapshots: readonly SemanticInputDocumentSnapshot[];
 }
 
 /**
@@ -529,6 +542,8 @@ export class LspClient {
     private readonly onLifecycleTransition?: LspClientLifecycleListener,
     /** Absolute workspace root for debug-telemetry identity. */
     readonly cwd?: string,
+    /** Immutable workspace association snapshot for document language IDs. */
+    fileAssociations?: CFamilyFileAssociationResolver,
   ) {
     this.name = name;
     this.root = root;
@@ -562,6 +577,7 @@ export class LspClient {
     this.diagnostics = new ClientDiagnostics({
       server: name,
       cwd: cwd,
+      fileAssociations,
       isOperational: () => this.rpc !== null && this._status === "running",
       diagnosticRequestAdapter: this.diagnosticRequestAdapter,
       documentSync: () => this.getDocumentSyncOptions(),
@@ -1155,8 +1171,32 @@ export class LspClient {
     newName: string,
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<WorkspaceEdit | null>> {
+    return (
+      await this.renameDetailedWithSnapshots(filePath, position, newName, {
+        control,
+        snapshotFiles: [filePath],
+      })
+    ).result;
+  }
+
+  /** Run rename and retain the exact synchronized inputs verified by its transaction. */
+  async renameDetailedWithSnapshots(
+    filePath: string,
+    position: Position,
+    newName: string,
+    options: {
+      readonly control?: CodeRequestControl;
+      readonly snapshotFiles?: readonly string[];
+      /** Reject non-enrollment changes since this earlier rename request. */
+      readonly inputRevision?: number;
+    } = {},
+  ): Promise<RenameDetailedWithSnapshotsResult> {
+    const { control, snapshotFiles = [filePath] } = options;
     if (!this.supportsRename) {
-      return unavailableCodeQuery("The server does not advertise textDocument/rename.");
+      return {
+        result: unavailableCodeQuery("The server does not advertise textDocument/rename."),
+        documentSnapshots: [],
+      };
     }
     if (
       typeof filePath !== "string" ||
@@ -1165,9 +1205,12 @@ export class LspClient {
       typeof newName !== "string" ||
       newName.trim().length === 0
     ) {
-      return unavailableCodeQuery(
-        "Rename requires a valid file, position, and non-empty new name.",
-      );
+      return {
+        result: unavailableCodeQuery(
+          "Rename requires a valid file, position, and non-empty new name.",
+        ),
+        documentSnapshots: [],
+      };
     }
 
     const params = {
@@ -1175,22 +1218,39 @@ export class LspClient {
       position,
       newName,
     };
-    return this.runRefactorTransaction("textDocument/rename", control, async (transaction) => {
-      if (this.supportsPrepareRename) {
-        const prepared = await transaction.rpc.sendRequest(
-          "textDocument/prepareRename",
-          { textDocument: { uri: fileToUri(filePath) }, position },
-          control,
-        );
-        const preparationError = validatePrepareRenameResult(prepared, position);
-        if (preparationError) throw new Error(preparationError);
-        await transaction.assertCurrent();
-      }
-      return (await transaction.rpc.sendRequest("textDocument/rename", params, control)) as
-        | WorkspaceEdit
-        | null
-        | undefined;
-    });
+    let documentSnapshots: readonly SemanticInputDocumentSnapshot[] = [];
+    let inputRevision: number | undefined;
+    const requestedFiles = new Set(snapshotFiles.map((file) => path.resolve(file)));
+    const result = await this.runRefactorTransaction(
+      "textDocument/rename",
+      control,
+      async (transaction) => {
+        if (this.supportsPrepareRename) {
+          const prepared = await transaction.rpc.sendRequest(
+            "textDocument/prepareRename",
+            { textDocument: { uri: fileToUri(filePath) }, position },
+            control,
+          );
+          const preparationError = validatePrepareRenameResult(prepared, position);
+          if (preparationError) throw new Error(preparationError);
+          await transaction.assertCurrent();
+        }
+        return (await transaction.rpc.sendRequest("textDocument/rename", params, control)) as
+          | WorkspaceEdit
+          | null
+          | undefined;
+      },
+      {
+        inputRevision: options.inputRevision,
+        onVerifiedSnapshot: (snapshot) => {
+          inputRevision = snapshot.revision;
+          documentSnapshots = snapshot.documents.filter((document) =>
+            requestedFiles.has(path.resolve(document.filePath)),
+          );
+        },
+      },
+    );
+    return { result, documentSnapshots, inputRevision };
   }
 
   async codeActions(
@@ -1247,7 +1307,9 @@ export class LspClient {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>> {
     if (!this.capabilities?.implementationProvider) {
-      return unavailableCodeQuery("Implementation requests are not supported by this server.");
+      return unavailableCodeQuery(
+        `LSP server "${this.name}" does not advertise textDocument/implementation.`,
+      );
     }
     return this.query(
       "textDocument/implementation",
@@ -1300,6 +1362,10 @@ export class LspClient {
     method: string,
     control: CodeRequestControl | undefined,
     operation: (transaction: RefactorTransaction) => Promise<T | null | undefined>,
+    options: {
+      readonly onVerifiedSnapshot?: (snapshot: SemanticInputSnapshot) => void;
+      readonly inputRevision?: number;
+    } = {},
   ): Promise<CodeQueryResult<T | null>> {
     throwIfCodeRequestInterrupted(control);
     if (!this.rpc || this._status !== "running") {
@@ -1308,8 +1374,9 @@ export class LspClient {
       );
     }
 
-    const retryGuard = new SemanticInputRequestRetryGuard((revision) =>
-      this.diagnostics.getSemanticInputChangeSince(revision),
+    const retryGuard = new SemanticInputRequestRetryGuard(
+      (revision) => this.diagnostics.getSemanticInputChangeSince(revision),
+      { inputRevision: options.inputRevision },
     );
     for (;;) {
       const attempt: SemanticRequestAttemptState = { inputRevision: undefined };
@@ -1321,9 +1388,10 @@ export class LspClient {
           operation,
           retryGuard,
           attempt,
+          onVerifiedSnapshot: options.onVerifiedSnapshot,
         });
         if (retryGuard.hasRetried) {
-          this.recordSemanticRetry({ method, control, retryGuard, outcome: "completed" });
+          this.recordRequestRetry({ method, control, retryGuard, outcome: "completed" });
         }
         return completedCodeQuery(data);
       } catch (error) {
@@ -1364,8 +1432,9 @@ export class LspClient {
     operation: (transaction: RefactorTransaction) => Promise<T | null | undefined>;
     retryGuard: SemanticInputRequestRetryGuard;
     attempt: SemanticRequestAttemptState;
+    onVerifiedSnapshot?: (snapshot: SemanticInputSnapshot) => void;
   }): Promise<T | null> {
-    const { method, control, operation, retryGuard, attempt } = options;
+    const { method, control, operation, retryGuard, attempt, onVerifiedSnapshot } = options;
     throwIfCodeRequestInterrupted(control);
     retryGuard.assertCurrent();
     await this.getReady(control);
@@ -1381,10 +1450,14 @@ export class LspClient {
       rpc,
       assertCurrent: async () => {
         retryGuard.assertCurrent();
-        await this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
+        return this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
       },
     });
-    await this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
+    const verifiedSnapshot = await this.diagnostics.assertSemanticInputsCurrent(
+      inputSnapshot,
+      control,
+    );
+    onVerifiedSnapshot?.(verifiedSnapshot);
     return data ?? null;
   }
 
@@ -1418,8 +1491,9 @@ export class LspClient {
     params: unknown,
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<T | null>> {
-    const retryGuard = new SemanticInputRequestRetryGuard((revision) =>
-      this.diagnostics.getSemanticInputChangeSince(revision),
+    const retryGuard = new SemanticInputRequestRetryGuard(
+      (revision) => this.diagnostics.getSemanticInputChangeSince(revision),
+      { retryContentModified: true },
     );
     for (;;) {
       const attempt: SemanticRequestAttemptState = { inputRevision: undefined };
@@ -1432,7 +1506,7 @@ export class LspClient {
           attempt,
         });
         if (retryGuard.hasRetried) {
-          this.recordSemanticRetry({ method, control, retryGuard, outcome: "completed" });
+          this.recordRequestRetry({ method, control, retryGuard, outcome: "completed" });
         }
         return completedCodeQuery(data);
       } catch (error) {
@@ -1452,7 +1526,7 @@ export class LspClient {
     const { method, control, retryGuard, attempt, error } = options;
     if (isCodeRequestInterruption(error, control)) {
       if (retryGuard.hasRetried) {
-        this.recordSemanticRetry({ method, control, retryGuard, outcome: "interrupted" });
+        this.recordRequestRetry({ method, control, retryGuard, outcome: "interrupted" });
       }
       throwIfCodeRequestInterrupted(control);
       throw error;
@@ -1461,17 +1535,32 @@ export class LspClient {
     const decision = retryGuard.decide(error, attempt.inputRevision);
     if (decision.kind === "retry") {
       throwIfCodeRequestInterrupted(control);
-      this.recordSemanticRetry({ method, control, retryGuard, outcome: "retry", error });
+      this.recordRequestRetry({
+        method,
+        control,
+        retryGuard,
+        outcome: "retry",
+        retryReason: decision.reason,
+        error,
+      });
       return;
     }
     if (retryGuard.hasRetried) {
-      const outcome = isSemanticInputEnrollmentError(decision.error) ? "exhausted" : "failed";
-      this.recordSemanticRetry({ method, control, retryGuard, outcome, error: decision.error });
+      const outcome = decision.reason ? "exhausted" : "failed";
+      this.recordRequestRetry({
+        method,
+        control,
+        retryGuard,
+        outcome,
+        retryReason: retryGuard.retryReason,
+        failureReason: decision.reason,
+        error: decision.error,
+      });
       const detail =
         decision.error instanceof Error ? decision.error.message : String(decision.error);
       const count = retryGuard.retryCount;
       throw new Error(
-        `${detail} Enrollment retry ${outcome} after ${count} ${count === 1 ? "retry" : "retries"}.`,
+        `${detail} Request retry ${outcome} after ${count} ${count === 1 ? "retry" : "retries"}.`,
         {
           cause: decision.error,
         },
@@ -1481,18 +1570,20 @@ export class LspClient {
   }
 
   /** Record request acceptance separately from transport completion, without request content. */
-  private recordSemanticRetry(options: {
+  private recordRequestRetry(options: {
     method: string;
     control?: CodeRequestControl;
     retryGuard: SemanticInputRequestRetryGuard;
     outcome: "retry" | "completed" | "exhausted" | "failed" | "interrupted";
+    retryReason?: SemanticInputRequestRetryReason;
+    failureReason?: SemanticInputRequestRetryReason;
     error?: unknown;
   }): void {
     recordDebugEvent({
       source: "lsp",
       level: "debug",
-      category: "semantic-request.enrollment-retry",
-      message: "LSP semantic request enrollment retry",
+      category: "request.retry",
+      message: "LSP request retry",
       cwd: boundCwd(this.cwd),
       ...(options.control?.operationId ? { operationId: options.control.operationId } : {}),
       data: {
@@ -1500,6 +1591,8 @@ export class LspClient {
         method: truncateIdentity(options.method),
         outcome: options.outcome,
         retryCount: options.retryGuard.retryCount,
+        retryReason: options.retryReason ?? options.retryGuard.retryReason ?? null,
+        failureReason: options.failureReason ?? null,
         changeKind:
           options.error instanceof SemanticInputSynchronizationError
             ? options.error.changeKind