@herbertgao/pi-extensions 2026.8.11 → 2026.8.13

package/node_modules/pi-lens/dist/clients/lsp/edits.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { URL } from "node:url";
 import { isUnderDir, normalizeEphemeralMapKey, normalizeMapKey, pathsEqual, uriToDiskPath, uriToPath, } from "./path-utils.js";
 import { convertCharacterOffset, lineTextAt, } from "./position-encoding.js";
-import { recordLspMutation, } from "../lsp-mutation.js";
+import { recordLspMutation } from "../lsp-mutation.js";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, } from "../host-edit-normalize.js";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -27,7 +27,7 @@ function isRange(value) {
     return comparePosition(value.start, value.end) <= 0;
 }
 function isTextEdit(value) {
-    return isRecord(value) && isRange(value.range) && typeof value.newText === "string";
+    return (isRecord(value) && isRange(value.range) && typeof value.newText === "string");
 }
 function parseTextEdits(value, context) {
     if (!Array.isArray(value))
@@ -39,7 +39,9 @@ function parseTextEdits(value, context) {
 function parseVersion(value, context) {
     if (value === undefined || value === null)
         return value;
-    if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+    if (!Number.isFinite(value) ||
+        !Number.isInteger(value) ||
+        value < 0) {
         throw new Error(`${context}.version must be a nonnegative integer or null`);
     }
     return value;
@@ -92,7 +94,8 @@ function parseWorkspaceEdit(edit) {
             parseTextEdits(edits, `changes[${uri}]`);
         }
     }
-    if (edit.documentChanges !== undefined && !Array.isArray(edit.documentChanges)) {
+    if (edit.documentChanges !== undefined &&
+        !Array.isArray(edit.documentChanges)) {
         throw new Error("workspace edit documentChanges must be an array");
     }
     for (const [index, change] of (edit.documentChanges ?? []).entries()) {
@@ -109,7 +112,8 @@ function parseWorkspaceEdit(edit) {
                 parseResourceOptions(change.options, "create");
                 break;
             case "rename":
-                if (typeof change.oldUri !== "string" || typeof change.newUri !== "string") {
+                if (typeof change.oldUri !== "string" ||
+                    typeof change.newUri !== "string") {
                     throw new Error("rename requires oldUri and newUri strings");
                 }
                 parseResourceOptions(change.options, "rename");
@@ -128,7 +132,7 @@ function formatRange(range) {
     return `${range.start.line + 1}:${range.start.character + 1}-${range.end.line + 1}:${range.end.character + 1}`;
 }
 export function rangesOverlap(a, b) {
-    return comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0;
+    return (comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0);
 }
 function positionsEqual(a, b) {
     return a.line === b.line && a.character === b.character;
@@ -233,7 +237,10 @@ function utf16Position(content, position, encoding) {
         if (encoding === "utf-32" && offset > 0 && offset < line.length) {
             const previous = line.charCodeAt(offset - 1);
             const current = line.charCodeAt(offset);
-            if (previous >= 0xd800 && previous <= 0xdbff && current >= 0xdc00 && current <= 0xdfff)
+            if (previous >= 0xd800 &&
+                previous <= 0xdbff &&
+                current >= 0xdc00 &&
+                current <= 0xdfff)
                 continue;
         }
         if (convertCharacterOffset(encoding, line, offset) === position.character) {
@@ -287,12 +294,17 @@ export function applyTextEditsToString(content, edits, positionEncoding = "utf-1
         const { start, end } = edit.range;
         if (start.line === end.line) {
             const line = lines[start.line] ?? "";
-            lines[start.line] = line.slice(0, start.character) + edit.newText + line.slice(end.character);
+            lines[start.line] =
+                line.slice(0, start.character) +
+                    edit.newText +
+                    line.slice(end.character);
             continue;
         }
         const startLine = lines[start.line] ?? "";
         const endLine = lines[end.line] ?? "";
-        const replacement = startLine.slice(0, start.character) + edit.newText + endLine.slice(end.character);
+        const replacement = startLine.slice(0, start.character) +
+            edit.newText +
+            endLine.slice(end.character);
         lines.splice(start.line, end.line - start.line + 1, ...replacement.split("\n"));
     }
     return lines.join("\n");
@@ -306,7 +318,9 @@ export async function normalizeWorkspaceEditToUtf16(edit, positionEncoding, cwd)
     // followed by a text edit at newDir/file.ts: the destination is not on disk
     // yet, but its content is available through the virtual move.
     const planned = planWorkspaceEdit(edit, true);
-    const prepared = await preflightWorkspaceEdit(planned, cwd, { positionEncoding });
+    const prepared = await preflightWorkspaceEdit(planned, cwd, {
+        positionEncoding,
+    });
     const normalizedByOrigin = new Map();
     for (const op of planned) {
         if (op.kind !== "text")
@@ -317,7 +331,8 @@ export async function normalizeWorkspaceEditToUtf16(edit, positionEncoding, cwd)
     }
     const changes = {};
     for (const uri of Object.keys(edit.changes ?? {})) {
-        changes[uri] = normalizedByOrigin.get(textEditOriginKey({ kind: "changes", uri, edits: [] })) ?? [];
+        changes[uri] =
+            normalizedByOrigin.get(textEditOriginKey({ kind: "changes", uri, edits: [] })) ?? [];
     }
     const documentChanges = [];
     for (const [index, change] of (edit.documentChanges ?? []).entries()) {
@@ -360,7 +375,14 @@ export function flattenWorkspaceTextEdits(edit) {
     return new Map([...buckets.values()].map(({ uri, edits }) => [uri, edits]));
 }
 function textEditKey(uri, edit) {
-    return [pathIndexKey(uri), edit.range.start.line, edit.range.start.character, edit.range.end.line, edit.range.end.character, edit.newText].join(":");
+    return [
+        pathIndexKey(uri),
+        edit.range.start.line,
+        edit.range.start.character,
+        edit.range.end.line,
+        edit.range.end.character,
+        edit.newText,
+    ].join(":");
 }
 export function mergeWorkspaceTextEditsByPriority(entries) {
     const merged = new Map();
@@ -387,7 +409,9 @@ export function mergeWorkspaceTextEditsByPriority(entries) {
             const kept = bucket.edits;
             for (const edit of edits) {
                 inputEditCount += 1;
-                const exactKey = isEmptyRange(edit.range) ? undefined : textEditKey(uri, edit);
+                const exactKey = isEmptyRange(edit.range)
+                    ? undefined
+                    : textEditKey(uri, edit);
                 if (exactKey !== undefined && seenExact.has(exactKey))
                     continue;
                 if (kept.some((existing) => rangesOverlap(existing.range, edit.range))) {
@@ -426,11 +450,24 @@ function textEditOriginKey(origin) {
 function parseResource(change) {
     const kind = change.kind;
     if (kind === "create")
-        return { kind, uri: change.uri, options: parseResourceOptions(change.options, kind) };
+        return {
+            kind,
+            uri: change.uri,
+            options: parseResourceOptions(change.options, kind),
+        };
     if (kind === "rename")
-        return { kind, oldUri: change.oldUri, newUri: change.newUri, options: parseResourceOptions(change.options, kind) };
+        return {
+            kind,
+            oldUri: change.oldUri,
+            newUri: change.newUri,
+            options: parseResourceOptions(change.options, kind),
+        };
     if (kind === "delete")
-        return { kind, uri: change.uri, options: parseResourceOptions(change.options, kind) };
+        return {
+            kind,
+            uri: change.uri,
+            options: parseResourceOptions(change.options, kind),
+        };
     throw new Error(`unsupported workspace resource operation: ${String(kind)}`);
 }
 function planWorkspaceEdit(edit, trackOrigins = false) {
@@ -484,7 +521,9 @@ function planWorkspaceEdit(edit, trackOrigins = false) {
             // fires for numeric `op.version`) still validates it.
             const existingNumeric = typeof existing.version === "number" ? existing.version : undefined;
             const incomingNumeric = typeof version === "number" ? version : undefined;
-            if (existingNumeric !== undefined && incomingNumeric !== undefined && existingNumeric !== incomingNumeric) {
+            if (existingNumeric !== undefined &&
+                incomingNumeric !== undefined &&
+                existingNumeric !== incomingNumeric) {
                 throw new Error(`conflicting text document versions for ${uri}`);
             }
             existing.edits.push(...edits);
@@ -519,7 +558,12 @@ function planWorkspaceEdit(edit, trackOrigins = false) {
             });
         }
         else {
-            ops.push({ kind: "text", uri: item.uri, edits: item.edits, version: item.version });
+            ops.push({
+                kind: "text",
+                uri: item.uri,
+                edits: item.edits,
+                version: item.version,
+            });
         }
     };
     const flushSubtree = (uri) => {
@@ -621,7 +665,9 @@ export function summarizeWorkspaceEdit(edit, cwd) {
             continue;
         if (change.kind === "create" && typeof change.uri === "string")
             lines.push(`Create ${relativeToCwd(uriToPath(change.uri), cwd)}`);
-        else if (change.kind === "rename" && typeof change.oldUri === "string" && typeof change.newUri === "string")
+        else if (change.kind === "rename" &&
+            typeof change.oldUri === "string" &&
+            typeof change.newUri === "string")
             lines.push(`Rename ${relativeToCwd(uriToPath(change.oldUri), cwd)} → ${relativeToCwd(uriToPath(change.newUri), cwd)}`);
         else if (change.kind === "delete" && typeof change.uri === "string")
             lines.push(`Delete ${relativeToCwd(uriToPath(change.uri), cwd)}`);
@@ -721,7 +767,8 @@ async function createWorkspaceUriConfiner(cwd) {
         let filePath = "";
         try {
             const parsed = new URL(uri);
-            if (parsed.protocol !== "file:" || (parsed.host !== "" && parsed.hostname !== "localhost"))
+            if (parsed.protocol !== "file:" ||
+                (parsed.host !== "" && parsed.hostname !== "localhost"))
                 throw new Error("URI must be a local file URI");
             filePath = uriToPath(uri);
         }
@@ -779,7 +826,8 @@ async function preflightWorkspaceEdit(planned, cwd, options) {
     const clearTombstonesUnder = (filePath) => {
         for (let index = virtualTombstones.length - 1; index >= 0; index--) {
             const tombstone = virtualTombstones[index];
-            if (pathsEqual(tombstone.path, filePath) || isUnderDir(tombstone.path, filePath)) {
+            if (pathsEqual(tombstone.path, filePath) ||
+                isUnderDir(tombstone.path, filePath)) {
                 virtualTombstones.splice(index, 1);
             }
         }
@@ -789,14 +837,20 @@ async function preflightWorkspaceEdit(planned, cwd, options) {
             return { exists: false, directory: false };
         const physicalPath = resolveVirtualPath(filePath);
         if (!physicalPath) {
-            return virtualOverrides.get(normalizeMapKey(filePath)) ?? { exists: false, directory: false };
+            return (virtualOverrides.get(normalizeMapKey(filePath)) ?? {
+                exists: false,
+                directory: false,
+            });
         }
         const key = normalizeMapKey(physicalPath);
         const known = virtual.get(key);
         if (known)
             return known;
         const stat = await lstatOrMissing(physicalPath);
-        const value = { exists: Boolean(stat), directory: stat?.isDirectory() ?? false };
+        const value = {
+            exists: Boolean(stat),
+            directory: stat?.isDirectory() ?? false,
+        };
         virtual.set(key, value);
         return value;
     };
@@ -880,7 +934,8 @@ async function preflightWorkspaceEdit(planned, cwd, options) {
             // treat a same-key-different-case pair as a real rename below.
             const oldDisk = uriToDiskPath(op.oldUri);
             const newDisk = uriToDiskPath(op.newUri);
-            if (path.resolve(oldDisk).replace(/\\/g, "/") === path.resolve(newDisk).replace(/\\/g, "/")) {
+            if (path.resolve(oldDisk).replace(/\\/g, "/") ===
+                path.resolve(newDisk).replace(/\\/g, "/")) {
                 throw new Error("rename source and destination must differ");
             }
             const source = await stateFor(oldPath);
@@ -953,7 +1008,11 @@ async function preflightWorkspaceEdit(planned, cwd, options) {
                 // resolves through this virtual move to the original physical path.
                 // This preserves ordered workspace-edit semantics without walking the
                 // entire subtree during preflight.
-                virtualMoves.push({ from: oldPath, to: newPath, directory: source.directory });
+                virtualMoves.push({
+                    from: oldPath,
+                    to: newPath,
+                    directory: source.directory,
+                });
             }
             continue;
         }
@@ -1047,7 +1106,11 @@ export async function applyWorkspaceEdit(edit, cwd, options = {}) {
                 const start = Math.min(...edits.map((item) => item.range.start.line + 1));
                 const end = Math.max(...edits.map((item) => item.range.end.line + 1));
                 touchedFiles.add(filePath);
-                fileDetails.push({ filePath, range: { start, end }, importsChanged: importsSignature(content) !== importsSignature(updated) });
+                fileDetails.push({
+                    filePath,
+                    range: { start, end },
+                    importsChanged: importsSignature(content) !== importsSignature(updated),
+                });
                 markApplied(op);
                 descriptions.push(`Applied ${edits.length} edit(s) to ${relativeToCwd(filePath, cwd)}`);
             }
@@ -1062,7 +1125,11 @@ export async function applyWorkspaceEdit(edit, cwd, options = {}) {
                 else
                     await fs.writeFile(diskPath, "", { flag: "wx" });
                 touchedFiles.add(filePath);
-                fileDetails.push({ filePath, range: { start: 1, end: 1 }, importsChanged: false });
+                fileDetails.push({
+                    filePath,
+                    range: { start: 1, end: 1 },
+                    importsChanged: false,
+                });
                 markApplied(op);
                 descriptions.push(`Created ${relativeToCwd(filePath, cwd)}`);
             }
@@ -1079,16 +1146,31 @@ export async function applyWorkspaceEdit(edit, cwd, options = {}) {
                 await fs.rename(oldDisk, newDisk);
                 touchedFiles.add(oldPath);
                 touchedFiles.add(newPath);
-                fileDetails.push({ filePath: oldPath, range: { start: 1, end: 1 }, importsChanged: true }, { filePath: newPath, range: { start: 1, end: 1 }, importsChanged: true });
+                fileDetails.push({
+                    filePath: oldPath,
+                    range: { start: 1, end: 1 },
+                    importsChanged: true,
+                }, {
+                    filePath: newPath,
+                    range: { start: 1, end: 1 },
+                    importsChanged: true,
+                });
                 markApplied(op);
                 descriptions.push(`Renamed ${relativeToCwd(oldPath, cwd)} → ${relativeToCwd(newPath, cwd)}`);
             }
             else {
                 const filePath = uriToPath(op.uri);
                 const diskPath = uriToDiskPath(op.uri);
-                await fs.rm(diskPath, { recursive: op.options?.recursive === true, force: false });
+                await fs.rm(diskPath, {
+                    recursive: op.options?.recursive === true,
+                    force: false,
+                });
                 touchedFiles.add(filePath);
-                fileDetails.push({ filePath, range: { start: 1, end: 1 }, importsChanged: true });
+                fileDetails.push({
+                    filePath,
+                    range: { start: 1, end: 1 },
+                    importsChanged: true,
+                });
                 markApplied(op);
                 descriptions.push(`Deleted ${relativeToCwd(filePath, cwd)}`);
             }
@@ -1097,11 +1179,16 @@ export async function applyWorkspaceEdit(edit, cwd, options = {}) {
     catch (err) {
         const partial = makeResult();
         if (options.mutationContext && options.observe !== false) {
-            recordLspMutation(options.mutationContext, { results: [partial], status: "failed" });
+            recordLspMutation(options.mutationContext, {
+                results: [partial],
+                status: "failed",
+            });
         }
         const already = [...touchedFiles];
         if (already.length > 0) {
-            const alreadyList = already.map((f) => `  • ${relativeToCwd(f, cwd)}`).join("\n");
+            const alreadyList = already
+                .map((f) => `  • ${relativeToCwd(f, cwd)}`)
+                .join("\n");
             const failure = new Error(`Workspace edit failed mid-application — ${already.length} file(s) already written, no rollback performed:\n${alreadyList}\nCause: ${err instanceof Error ? err.message : String(err)}`);
             failure.appliedWorkspaceEdit = partial;
             throw failure;

package/node_modules/pi-lens/dist/clients/lsp/index.js

@@ -12,7 +12,7 @@ import * as nodeFs from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL, URL } from "node:url";
-import { getProjectIgnoreMatcher, isExcludedDirName, } from "../file-utils.js";
+import { getProjectIgnoreMatcher, isExcludedDirName } from "../file-utils.js";
 import { recordLsp } from "../widget-state.js";
 import { applyAuxiliarySuppressions } from "../dispatch/auxiliary-lsp.js";
 import { detectFileRole } from "../file-role.js";
@@ -25,11 +25,12 @@ import { shouldPreferPullOnlyDiagnostics } from "../lsp-budget.js";
 import { withDeadline, withTimeout } from "../deadline-utils.js";
 import { acquireWorkspaceSweepHold, clearWorkspaceSweepHoldForSessionStart, } from "./workspace-sweep-hold.js";
 import { DocumentDriftTracker, fingerprintDocumentContent, } from "./document-drift.js";
+import { markPendingAuxiliaryCoverage } from "./pending-aux-coverage.js";
 import { isAtOrAboveHomeDir, isWindowsPath, normalizeMapKey, uriToPath, } from "../path-utils.js";
-import { recordLspMutation, } from "../lsp-mutation.js";
+import { recordLspMutation } from "../lsp-mutation.js";
 import { createLSPClient } from "./client.js";
 import { auxiliaryCoverageGap, bindingStateLabel, composeBoundToCurrentDisk, createDiskBindingCache, hashDiagnosticContent, resolveTouchVerdict, touchCoverageGap, } from "./diagnostic-binding.js";
-import { getServersForFileWithConfig, getServerInitOverride } from "./config.js";
+import { getServersForFileWithConfig, getServerInitOverride, } from "./config.js";
 import { getLanguageId } from "./language.js";
 import { LSP_SERVERS, enforceLspRootCeiling, hasProjectBoundaryMarker, isDirectLspCommandTemporarilyUnavailable, resetClassicTsRepairGuard, } from "./server.js";
 import { classifyCascadeWaitTier, classifyServerWaitTier, getStrategy, } from "./wait-policy/index.js";
@@ -37,8 +38,8 @@ const WORKSPACE_ATTRIBUTION_CLIENT_CAP = 16;
 import { raceToCompletion } from "./aggregation.js";
 import { applyWorkspaceEdit, mergeWorkspaceTextEditsByPriority, summarizeWorkspaceEdit, validateWorkspaceEdit, } from "./edits.js";
 import { buildScopeKey, createWorkspaceDiagnosticsCacheContext, } from "./workspace-diagnostics-cache.js";
-import { attemptTsserverSyncDiagnostics, } from "./tsserver-sync.js";
-import { isWarmAttached, tryWarmAttachedDiagnostics, } from "../warm-attach.js";
+import { attemptTsserverSyncDiagnostics } from "./tsserver-sync.js";
+import { isWarmAttached, tryWarmAttachedDiagnostics } from "../warm-attach.js";
 import { getSuccessfulLspSpawnDurationMs, recordSuccessfulLspSpawn, } from "./spawn-history.js";
 function destinationUriPreservingSpelling(oldUri, oldFilePath, newFilePath) {
     const canonical = pathToFileURL(newFilePath);
@@ -475,7 +476,9 @@ function notifyWedgedMs() {
 const AUX_NOTIFY_INFLIGHT_DEFAULT = 8;
 function auxNotifyInflightLimit(info) {
     const perServer = info.notifyInflightLimit;
-    if (typeof perServer === "number" && Number.isFinite(perServer) && perServer > 0) {
+    if (typeof perServer === "number" &&
+        Number.isFinite(perServer) &&
+        perServer > 0) {
         return Math.floor(perServer);
     }
     const raw = Number(process.env.PI_LENS_LSP_AUX_NOTIFY_INFLIGHT);
@@ -904,8 +907,12 @@ export class LSPService {
             client.isAlive() &&
             client.isBusy?.() !== true &&
             (this.clientLeases.get(candidateKey) ?? 0) === 0)
-            .sort(([a], [b]) => (this.clientLastUsedAt.get(a) ?? this.state.clientSpawnedAt.get(a) ?? 0) -
-            (this.clientLastUsedAt.get(b) ?? this.state.clientSpawnedAt.get(b) ?? 0));
+            .sort(([a], [b]) => (this.clientLastUsedAt.get(a) ??
+            this.state.clientSpawnedAt.get(a) ??
+            0) -
+            (this.clientLastUsedAt.get(b) ??
+                this.state.clientSpawnedAt.get(b) ??
+                0));
         const victim = idle[0];
         if (!victim) {
             logSessionStart(`lsp client ceiling ${getLspClientCeiling()}: spawn declined; all clients are in use`);
@@ -1601,7 +1608,8 @@ export class LSPService {
         });
         const noteSpawnInFlight = (serverId) => {
             const knownDurationMs = getSuccessfulLspSpawnDurationMs(serverId);
-            if (knownDurationMs !== undefined && knownDurationMs > effectiveMaxWaitMs * 2) {
+            if (knownDurationMs !== undefined &&
+                knownDurationMs > effectiveMaxWaitMs * 2) {
                 // Let a completion microtask already queued by the acquisition win
                 // before the shortcut decision is observed by Promise.race.
                 queueMicrotask(() => knownSlowResolve?.());
@@ -1868,6 +1876,34 @@ export class LSPService {
         }
         return false;
     }
+    /**
+     * #2001/#2002 collect-later: read-only cached-diagnostics probe for the
+     * turn-end late-auxiliary delivery (`clients/runtime-turn.ts`). Like
+     * `isServerAliveForFile`, this NEVER creates or warms a client — it only
+     * resolves each requested server's root and reads the already-connected
+     * client's cached diagnostics for `filePath`. Servers with no live client
+     * are simply absent from the returned map (the caller drops those pairs
+     * silently); a present server maps to its cache contents, possibly empty
+     * (still scanning).
+     */
+    async readCachedDiagnosticsForServers(filePath, serverIds) {
+        const out = new Map();
+        if (this.checkDestroyed() || serverIds.size === 0)
+            return out;
+        for (const server of getServersForFileWithConfig(filePath)) {
+            if (!serverIds.has(server.id) || out.has(server.id))
+                continue;
+            const root = await this.resolveServerRoot(server, filePath);
+            if (!root)
+                continue;
+            const key = `${server.id}:${normalizeMapKey(root)}`;
+            const client = this.state.clients.get(key);
+            if (!client?.isAlive())
+                continue;
+            out.set(server.id, client.getDiagnostics(filePath));
+        }
+        return out;
+    }
     /**
      * #1668: deliver a `workspace/didChangeWatchedFiles` event for a disk
      * change the client did not author through open-document sync — a bash
@@ -2262,8 +2298,7 @@ export class LSPService {
                 // single death may feed BOTH accumulators (the window above AND
                 // runtimeExitCounts here), but neither alters the other's threshold,
                 // so the fast path's trip point is exactly what it was.
-                if (uptimeMs != null &&
-                    uptimeMs < RUNTIME_EXIT_UPTIME_THRESHOLD_MS) {
+                if (uptimeMs != null && uptimeMs < RUNTIME_EXIT_UPTIME_THRESHOLD_MS) {
                     const rCount = (this.runtimeExitCounts.get(key) ?? 0) + 1;
                     this.runtimeExitCounts.set(key, rCount);
                     const rCooldown = Math.min(BROKEN_BASE_COOLDOWN_MS * 2 ** (rCount - 1), BROKEN_MAX_COOLDOWN_MS);
@@ -2941,7 +2976,8 @@ export class LSPService {
                                 // stall was long enough that #743's demotion is the honest
                                 // verdict, not a latency artifact.
                                 const outstandingMs = Date.now() - writeStartedAt;
-                                if (outstandingMs > budget && outstandingMs <= notifyWedgedMs()) {
+                                if (outstandingMs > budget &&
+                                    outstandingMs <= notifyWedgedMs()) {
                                     this.retractNotifyWriteBackpressure(clientKey, entry.info.id, filePath, outstandingMs, client);
                                 }
                             }, release);
@@ -3157,7 +3193,9 @@ export class LSPService {
                 // slow aux (opengrep) can't override the per-edit cap. Resolves as soon
                 // as a server publishes; this is just its individual deadline. (#242)
                 const perServerTimeout = (serverId) => {
-                    const launchVariant = spawned.find((entry) => entry.client.serverId === serverId)?.client.getLaunchVariant?.();
+                    const launchVariant = spawned
+                        .find((entry) => entry.client.serverId === serverId)
+                        ?.client.getLaunchVariant?.();
                     const strategy = getStrategy(serverId, launchVariant);
                     let strategyWait = strategy.aggregateWaitMs;
                     // #645: a `workspaceIndexing` server (marksman) only needs the
@@ -3319,7 +3357,8 @@ export class LSPService {
                     const isWarmupTouch = source === "lsp_sweep_warmup";
                     // #743: per-server — a server we DID push to still gets the
                     // version-baseline wait even when a sibling was debounced away.
-                    const wait = !notifySkippedServerIds.has(entry.info.id) && Number.isFinite(baseline)
+                    const wait = !notifySkippedServerIds.has(entry.info.id) &&
+                        Number.isFinite(baseline)
                         ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
                             minVersion: baseline,
                             ...(pullOnly && { pullOnly: true }),
@@ -3463,6 +3502,24 @@ export class LSPService {
                             const uncovered = auxiliaryCoverageGap(outcomes);
                             if (uncovered.length > 0)
                                 auxUnconfirmedServerIds = uncovered;
+                            // #2001/#2002 collect-later: an auxiliary with NO publication
+                            // evidence for this content (`cut_off` — our grace timer won; or
+                            // `silent` — its own budget lapsed with nothing published) may still
+                            // publish into its client cache seconds later. Mark the pair so the
+                            // NEXT turn_end can probe the cache and deliver the late findings
+                            // instead of dropping them on the floor. Exclusions mirror the
+                            // coverage-gap policy: `answered` already rode along, a #1493-exempt
+                            // scanner's stored findings are bound to exactly these bytes (its
+                            // answer is already carried), and DEFERRED servers never received
+                            // this content at all (#1459) — their cache describes the PREVIOUS
+                            // revision and probing it would replay stale findings.
+                            const collectLaterServerIds = outcomes
+                                .filter((o) => !o.publishedThisContent &&
+                                (o.outcome === "cut_off" || o.outcome === "silent"))
+                                .map((o) => o.serverId);
+                            if (collectLaterServerIds.length > 0) {
+                                markPendingAuxiliaryCoverage(filePath, collectLaterServerIds);
+                            }
                             logLatency({
                                 type: "phase",
                                 phase: "lsp_aux_wait_outcome",
@@ -3706,7 +3763,7 @@ export class LSPService {
                             return true;
                         }
                         try {
-                            return entry.client.getAllDiagnostics?.().has(normalizedPath) === true;
+                            return (entry.client.getAllDiagnostics?.().has(normalizedPath) === true);
                         }
                         catch {
                             // Fail closed: an unreadable cache is not evidence of an answer.
@@ -3963,9 +4020,8 @@ export class LSPService {
                         diagnosticsTimedOut = false;
                         retractPrimaryTimeoutAttribution(); // #1549
                         syncConfirmed = true;
-                        collected = syncResult.length > 0
-                            ? mergeLspDiagnostics(syncResult)
-                            : [];
+                        collected =
+                            syncResult.length > 0 ? mergeLspDiagnostics(syncResult) : [];
                         logLatency({
                             type: "phase",
                             phase: "lsp_tsserver_sync_confirm",
@@ -4030,7 +4086,8 @@ export class LSPService {
                 getStrategy(spawned[0].client.serverId, spawned[0].client.getLaunchVariant?.()).silentOnClean === true) {
                 try {
                     const snapshots = await this.getCapabilitySnapshots(filePath);
-                    if (classifyCascadeWaitTier(this, filePath, snapshots) === "tier3-silent") {
+                    if (classifyCascadeWaitTier(this, filePath, snapshots) ===
+                        "tier3-silent") {
                         // #1277: same liveness precondition as the aggregate gate above —
                         // `tier3-silent` is a static capability classification and can't
                         // distinguish "silent because clean" from "silent because wedged".
@@ -4183,7 +4240,9 @@ export class LSPService {
                     metadata: {
                         source,
                         clientScope,
-                        ...(brokenSkippedServerIds.length > 0 && { brokenSkippedServerIds }),
+                        ...(brokenSkippedServerIds.length > 0 && {
+                            brokenSkippedServerIds,
+                        }),
                         // #1586: the deferrals this touch is actually uncovered for. The raw
                         // gate action keeps its own record in `lsp_notify_resync_deferred`;
                         // this row exists to prove a blackout, and a scanner already bound to
@@ -4588,7 +4647,8 @@ export class LSPService {
             return (found ?? {
                 serverId: entry.info.id,
                 launchVariant: entry.client.getLaunchVariant?.(),
-                waitMs: getStrategy(entry.info.id, entry.client.getLaunchVariant?.()).aggregateWaitMs,
+                waitMs: getStrategy(entry.info.id, entry.client.getLaunchVariant?.())
+                    .aggregateWaitMs,
                 diagnosticCount: 0,
                 diagnostics: [],
             });
@@ -5307,21 +5367,23 @@ export class LSPService {
                         ...applied,
                         files,
                         operationTotal: applied.operationTotal + renameApplied.operationTotal,
-                        appliedOperationTotal: applied.appliedOperationTotal + renameApplied.appliedOperationTotal,
+                        appliedOperationTotal: applied.appliedOperationTotal +
+                            renameApplied.appliedOperationTotal,
                         appliedOperationIndexes: [
                             ...applied.appliedOperationIndexes,
                             ...renameApplied.appliedOperationIndexes.map((index) => applied.operationTotal + index),
                         ],
                         operationCounts: {
-                            textEdits: applied.operationCounts.textEdits + renameApplied.operationCounts.textEdits,
-                            create: applied.operationCounts.create + renameApplied.operationCounts.create,
-                            rename: applied.operationCounts.rename + renameApplied.operationCounts.rename,
-                            delete: applied.operationCounts.delete + renameApplied.operationCounts.delete,
+                            textEdits: applied.operationCounts.textEdits +
+                                renameApplied.operationCounts.textEdits,
+                            create: applied.operationCounts.create +
+                                renameApplied.operationCounts.create,
+                            rename: applied.operationCounts.rename +
+                                renameApplied.operationCounts.rename,
+                            delete: applied.operationCounts.delete +
+                                renameApplied.operationCounts.delete,
                         },
-                        fileDetails: [
-                            ...applied.fileDetails,
-                            ...renameApplied.fileDetails,
-                        ],
+                        fileDetails: [...applied.fileDetails, ...renameApplied.fileDetails],
                     },
                 ],
                 status: "success",
@@ -6136,9 +6198,7 @@ export class LSPService {
                 return;
             }
             // Fast path: one project-wide pull for the whole group (opt-in).
-            if (!isWarmAttached() &&
-                workspacePullEnabled &&
-                !group.multiServer) {
+            if (!isWarmAttached() && workspacePullEnabled && !group.multiServer) {
                 const pulled = await this.tryWorkspacePull(group.files, perFileMs, cacheServedKeys);
                 if (pulled) {
                     // #1782: an explicit zero-diagnostic answer for a file this
@@ -6468,8 +6528,7 @@ export class LSPService {
                 }
                 return true;
             }));
-            client.pruneDiagnostics((filePath, ts) => !existingPaths.has(filePath) ||
-                now - ts > CASCADE_DIAGNOSTICS_TTL_MS);
+            client.pruneDiagnostics((filePath, ts) => !existingPaths.has(filePath) || now - ts > CASCADE_DIAGNOSTICS_TTL_MS);
             const clientDiags = client.getAllDiagnostics();
             for (const [filePath, entry] of clientDiags) {
                 const existing = all.get(filePath);

package/node_modules/pi-lens/dist/clients/lsp/inferred-project.js

@@ -175,7 +175,8 @@ export async function demoteInferredProjectSweepResults(results, cwd, service, s
             out.push(result);
             continue;
         }
-        if (identityCache.size >= INFERRED_PROJECT_PROBE_BUDGET && !identityCache.has(result.filePath)) {
+        if (identityCache.size >= INFERRED_PROJECT_PROBE_BUDGET &&
+            !identityCache.has(result.filePath)) {
             budgetExhausted = true;
             out.push(result);
             continue;

package/node_modules/pi-lens/dist/clients/lsp/jvm-runtime.js

@@ -114,7 +114,10 @@ export function discoverJdkHome(roots = candidateRoots(), javaHome = process.env
             const resolved = jdkHomeFrom(dir);
             if (!resolved)
                 continue;
-            found.push({ home: resolved, major: parseMajorVersion(path.basename(dir)) });
+            found.push({
+                home: resolved,
+                major: parseMajorVersion(path.basename(dir)),
+            });
         }
     }
     // Require a parseable major ≥ 17 (jdtls's floor). An explicit JAVA_HOME is