@herbertgao/pi-extensions 2026.9.2 → 2026.9.4

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

@@ -34,7 +34,7 @@ import { markPendingAuxiliaryCoverage, napiFallbackCoveredSince, } from "./pendi
 import { isAtOrAboveHomeDir, isWindowsPath, normalizeMapKey, uriToPath, } from "../path-utils.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 { auxiliaryCoverageGap, auxiliaryPublicationEvidence, bindingStateLabel, composeBoundToCurrentDisk, createDiskBindingCache, hashDiagnosticContent, resolveTouchVerdict, touchCoverageGap, } from "./diagnostic-binding.js";
 import { getServersForFileWithConfig, getServerInitOverride, } from "./config.js";
 // #2052: deliberately NOT taken from `config.js`. This module's import surface
 // from `config.js` is mirrored by explicit `vi.mock` factories in ~58 test
@@ -42,9 +42,14 @@ import { getServersForFileWithConfig, getServerInitOverride, } from "./config.js
 import { getSessionRootsForTelemetry, isOutsideAllSessionRoots, } from "./session-roots.js";
 import { getProcessSingleton } from "../process-singletons.js";
 import { getLanguageId } from "./language.js";
-import { LSP_SERVERS, enforceLspRootCeiling, hasProjectBoundaryMarker, isDirectLspCommandTemporarilyUnavailable, resetClassicTsRepairGuard, resetLspLaunchAvailabilityGeneration, } from "./server.js";
+import { getReverseDepsFromIndex, loadReverseDependencyIndexFromSnapshot, } from "../reverse-deps.js";
+import { LSP_SERVERS, enforceLspRootCeiling, hasProjectBoundaryMarker, isDirectLspCommandTemporarilyUnavailable, resetClassicTsRepairGuard, resetLspLaunchAvailabilityGeneration, resolveLspServerCwd, } from "./server.js";
 import { classifyCascadeWaitTier, classifyServerWaitTier, getStrategy, } from "./wait-policy/index.js";
 const WORKSPACE_ATTRIBUTION_CLIENT_CAP = 16;
+const AUX_WAIT_DEMOTION_THRESHOLD = 5;
+const AUX_WAIT_DEMOTION_RATIO = 0.9;
+const AUX_WAIT_REPROMOTION_THRESHOLD = 5;
+const AUX_WAIT_REPROMOTION_RATIO = 0.5;
 import { raceToCompletion } from "./aggregation.js";
 import { applyWorkspaceEdit, mergeWorkspaceTextEditsByPriority, summarizeWorkspaceEdit, validateWorkspaceEdit, } from "./edits.js";
 import { buildScopeKey, createWorkspaceDiagnosticsCacheContext, } from "./workspace-diagnostics-cache.js";
@@ -176,6 +181,7 @@ const NAV_CLIENT_WAIT_TIMEOUT_MS = Math.max(0, Number.parseInt(process.env.PI_LE
     1500);
 const TOUCH_DEBOUNCE_MS = Math.max(0, Number.parseInt(process.env.PI_LENS_LSP_TOUCH_DEBOUNCE_MS ?? "1500", 10) ||
     1500);
+const SCOPED_DEPENDENCY_TOUCH_MAX = 32;
 // #1621: the rename-propagation notifies (`didClose` ahead of the rename,
 // `workspace/didRenameFiles` after) share the exit-notify defect #1620 fixed —
 // a notify write on a pipe that is not draining neither resolves nor rejects,
@@ -345,6 +351,9 @@ function mergeLspDiagnostics(diagnostics) {
     }
     return merged;
 }
+function attributeDiagnostics(serverId, diagnostics) {
+    return diagnostics.map((diagnostic) => ({ ...diagnostic, serverId }));
+}
 /**
  * Group files by their primary language server id (#387/#631 — extracted
  * from `runWorkspaceDiagnostics`'s inline grouping so other callers, e.g.
@@ -653,6 +662,11 @@ export class LSPService {
      * the navigation-only latch, so the next touch can try again.
      */
     firstContactWaits = new Map();
+    /** Session-scoped adaptive demotion for budget-hitting auxiliaries. */
+    auxWaitPressureStreak = new Map();
+    auxWaitFastAnswerStreak = new Map();
+    demotedAuxiliaryServerIds = new Set();
+    demotedAuxiliaryBudgets = new Map();
     /**
      * #1934 review F1: what the last COMPLETED `spawnClient` call for a
      * (server, root) key decided, written by that call at every point it
@@ -865,13 +879,61 @@ export class LSPService {
             diagnosticsUnsupported: new Set(),
         };
     }
+    isAuxiliaryWaitDemoted(serverId, root) {
+        return this.demotedAuxiliaryServerIds.has(`${serverId}:${normalizeMapKey(root ?? "")}`);
+    }
+    noteAuxiliaryWait(key, budgetMs, elapsedMs) {
+        if (this.demotedAuxiliaryServerIds.has(key))
+            return;
+        if (elapsedMs < AUX_WAIT_DEMOTION_RATIO * budgetMs) {
+            this.auxWaitPressureStreak.delete(key);
+            return;
+        }
+        const streak = (this.auxWaitPressureStreak.get(key) ?? 0) + 1;
+        if (streak >= AUX_WAIT_DEMOTION_THRESHOLD) {
+            this.demotedAuxiliaryServerIds.add(key);
+            this.demotedAuxiliaryBudgets.set(key, budgetMs);
+            this.auxWaitPressureStreak.delete(key);
+            this.auxWaitFastAnswerStreak.delete(key);
+            recordDegradationOnce({
+                kind: "aux_wait_demoted",
+                subject: key,
+                reason: "auxiliary reached at least 90% of its declared wait budget for five consecutive dispatches",
+            });
+            return;
+        }
+        this.auxWaitPressureStreak.set(key, streak);
+    }
+    noteAuxiliaryLateAnswer(key, elapsedMs) {
+        if (!this.demotedAuxiliaryServerIds.has(key))
+            return;
+        const budgetMs = this.demotedAuxiliaryBudgets.get(key);
+        if (budgetMs === undefined ||
+            elapsedMs >= AUX_WAIT_REPROMOTION_RATIO * budgetMs) {
+            this.auxWaitFastAnswerStreak.delete(key);
+            return;
+        }
+        const streak = (this.auxWaitFastAnswerStreak.get(key) ?? 0) + 1;
+        if (streak < AUX_WAIT_REPROMOTION_THRESHOLD) {
+            this.auxWaitFastAnswerStreak.set(key, streak);
+            return;
+        }
+        this.demotedAuxiliaryServerIds.delete(key);
+        this.demotedAuxiliaryBudgets.delete(key);
+        this.auxWaitFastAnswerStreak.delete(key);
+        recordDegradationOnce({
+            kind: "aux_wait_repromoted",
+            subject: key,
+            reason: "auxiliary produced five consecutive late answers below half its declared wait budget",
+        });
+    }
     /**
      * Resolve one server's client identity root. Root selection is hard-bounded
      * by the session cwd, then config-only nested roots reuse an already-hosted
      * same-server ancestor. Real nested projects retain independent clients.
      */
-    async resolveServerRoot(server, filePath) {
-        const candidate = await server.root(filePath);
+    async resolveServerRoot(server, filePath, onRootFailure) {
+        const candidate = await resolveLspServerCwd(server, filePath, this.sessionCwd ?? process.cwd(), onRootFailure);
         if (!candidate)
             return undefined;
         // #2052: a file outside EVERY initialized session cwd gets no client at
@@ -1995,11 +2057,14 @@ export class LSPService {
          */
         const partitionCandidates = async () => {
             const resolved = await Promise.all(servers.map(async (server) => {
+                let rootFailureReason;
                 try {
                     return {
                         server,
-                        root: await this.resolveServerRootOnce(server, filePath, rootMemo),
-                        reason: undefined,
+                        root: await this.resolveServerRootOnce(server, filePath, rootMemo, (reason) => {
+                            rootFailureReason = reason;
+                        }),
+                        reason: rootFailureReason,
                     };
                 }
                 catch (error) {
@@ -2466,6 +2531,18 @@ export class LSPService {
         }
         return out;
     }
+    /** Record a fast answer observed by the turn-end late-results path. */
+    async observeLateAuxiliaryAnswer(filePath, serverId, elapsedMs) {
+        for (const server of getServersForFileWithConfig(filePath)) {
+            if (server.id !== serverId)
+                continue;
+            const root = await this.resolveServerRoot(server, filePath);
+            if (root === undefined)
+                return;
+            this.noteAuxiliaryLateAnswer(`${serverId}:${normalizeMapKey(root)}`, elapsedMs);
+            return;
+        }
+    }
     /**
      * #1668: deliver a `workspace/didChangeWatchedFiles` event for a disk
      * change the client did not author through open-document sync — a bash
@@ -2492,6 +2569,45 @@ export class LSPService {
             }
         }
     }
+    /**
+     * Re-sync the open views affected by one recovered Git tree change. The
+     * recovery seam already owns the changed-path set, so this deliberately
+     * reads only the cached reverse-import index and never runs another diff.
+     */
+    async resyncGitChangedFiles(changedPaths) {
+        if (this.checkDestroyed() || changedPaths.length === 0)
+            return;
+        const targets = new Set();
+        for (const changedPath of changedPaths) {
+            const resolved = path.resolve(changedPath);
+            for (const server of getServersForFileWithConfig(resolved)) {
+                const root = await this.resolveServerRoot(server, resolved);
+                if (!root)
+                    continue;
+                const index = loadReverseDependencyIndexFromSnapshot({ cwd: root });
+                for (const importer of index
+                    ? getReverseDepsFromIndex(index, resolved)
+                    : []) {
+                    targets.add(importer);
+                }
+            }
+            targets.add(resolved);
+        }
+        const openTargets = [...targets].filter((filePath) => this.hasLiveClientHoldingDocument(filePath));
+        this.documentDrift.enqueueResync(openTargets);
+        const pass = await this.sweepDocumentDrift({ force: true });
+        logLatency({
+            type: "phase",
+            phase: "lsp_external_change_resync",
+            filePath: changedPaths[0] ?? "",
+            durationMs: 0,
+            metadata: {
+                changedCount: changedPaths.length,
+                enqueued: openTargets.length,
+                deferred: pass?.deferred ?? this.documentDrift.pendingResyncCount,
+            },
+        });
+    }
     /**
      * #1783: disk-drift backstop. Stat one batch of the documents a language
      * server currently holds, and re-push any whose bytes on disk no longer
@@ -2680,13 +2796,13 @@ export class LSPService {
      * instead of each taking their own. Without a `memo` this is a plain
      * passthrough, for callers that have no acquisition to share with.
      */
-    resolveServerRootOnce(server, filePath, memo) {
+    resolveServerRootOnce(server, filePath, memo, onRootFailure) {
         if (!memo)
-            return this.resolveServerRoot(server, filePath);
+            return this.resolveServerRoot(server, filePath, onRootFailure);
         const pending = memo.get(server.id);
         if (pending !== undefined)
             return pending;
-        const started = this.resolveServerRoot(server, filePath);
+        const started = this.resolveServerRoot(server, filePath, onRootFailure);
         memo.set(server.id, started);
         return started;
     }
@@ -3513,7 +3629,9 @@ export class LSPService {
                     if (!bindingMatchesTouchContent(binding))
                         return [];
                     const diags = entry.client.getDiagnostics(filePath);
-                    return diags.length > 0 ? [{ diags, binding }] : [];
+                    return diags.length > 0
+                        ? [{ serverId: entry.info.id, diags, binding }]
+                        : [];
                 })
                 : [];
             // #1493: auxiliaries whose STORED publication already covers exactly the
@@ -3822,6 +3940,15 @@ export class LSPService {
             // confirmation; `auxCutOffServerIds` stays cut_off-only so the R8 latency
             // field keeps its original meaning.
             let auxUnconfirmedServerIds;
+            // #2810: the auxiliaries this touch handed to the collect-later store —
+            // exactly the servers whose findings a turn-end drain can still deliver.
+            // Written by the ONE producer that marks them, from the same array it
+            // marks, so the promise the agent is shown cannot drift from the store.
+            // Round 3 derived the promise from the #1459 resync deferrals instead —
+            // the one set `pending-aux-coverage.ts` never marks — so the notice
+            // promised delivery that could not happen, while the demoted server,
+            // which IS marked, was reported as an unexplained silence on every edit.
+            let lateDeliveryServerIds;
             // #707: tsserver sync clean-confirm state. `tsserverSyncEligible` is the
             // full gate (evaluated once, before the wait); `tsserverSyncConfirmed`
             // holds the sync commands' answer when the racing confirm won the wait
@@ -4098,9 +4225,11 @@ export class LSPService {
                 const answeredForThisTouch = (entry) => {
                     const baseline = diagnosticBaselines.get(entry.client);
                     const currentPathVersion = readPathVersion(entry.client);
-                    if (Number.isFinite(baseline) &&
-                        currentPathVersion !== undefined &&
-                        currentPathVersion > baseline) {
+                    if (auxiliaryPublicationEvidence({
+                        bindingMatchesContent: false,
+                        baseline,
+                        currentPathVersion,
+                    })) {
                         return true;
                     }
                     try {
@@ -4116,6 +4245,11 @@ export class LSPService {
                         : perServerDeclaredTimeouts[entryIndex];
                 });
                 const perServerWaits = spawned.map((entry, entryIndex) => {
+                    if (hasTouchAuxiliaries &&
+                        entry.info.role === "auxiliary" &&
+                        this.isAuxiliaryWaitDemoted(entry.info.id, entry.client.root ?? filePath)) {
+                        return Promise.resolve(undefined);
+                    }
                     if (this.state.diagnosticsUnsupported.has(entry.info.id) ||
                         diagnosticsUnsupportedServerIds.includes(entry.info.id)) {
                         return Promise.resolve(undefined);
@@ -4254,6 +4388,8 @@ export class LSPService {
                                 client: spawned[i].client,
                                 baseline: diagnosticBaselines.get(spawned[i].client),
                                 budgetMs: perServerRaceBudgets[i],
+                                demoted: this.isAuxiliaryWaitDemoted(spawned[i].info.id, spawned[i].client.root ?? filePath),
+                                root: spawned[i].client.root ?? filePath,
                             }
                             : null)
                             .filter((x) => x !== null);
@@ -4273,6 +4409,22 @@ export class LSPService {
                             const auxWaitStartedAt = Date.now();
                             const outcomes = await Promise.all(auxWaits.map(async (aux) => {
                                 const { budgetMs } = aux;
+                                if (aux.demoted) {
+                                    return {
+                                        serverId: aux.serverId,
+                                        outcome: deferredResyncServerIds.has(aux.serverId)
+                                            ? "deferred"
+                                            : "demoted",
+                                        publishedThisContent: auxiliaryPublicationEvidence({
+                                            bindingMatchesContent: auxCoversThisContent(aux.serverId),
+                                            baseline: aux.baseline,
+                                            currentPathVersion: readPathVersion(aux.client),
+                                        }),
+                                        budgetMs,
+                                        elapsedMs: 0,
+                                        elapsedSinceNotifyMs: 0,
+                                    };
+                                }
                                 let timer;
                                 const timeout = new Promise((resolve) => {
                                     timer = setTimeout(() => resolve(false), budgetMs);
@@ -4311,10 +4463,12 @@ export class LSPService {
                                 // ignoring sibling paths — and it is the SAME axis `baseline`
                                 // was captured on above.
                                 const currentPathVersion = readPathVersion(aux.client);
-                                const publishedEvidence = raced &&
-                                    Number.isFinite(aux.baseline) &&
-                                    currentPathVersion !== undefined &&
-                                    currentPathVersion > aux.baseline;
+                                const publishedEvidence = auxiliaryPublicationEvidence({
+                                    bindingMatchesContent: false,
+                                    baseline: aux.baseline,
+                                    currentPathVersion,
+                                    raced,
+                                });
                                 // #1459: a DEFERRED aux was never sent this content and is not
                                 // waited on at all, so its instantly-resolved placeholder
                                 // promise must not read as "silent". "Silent" is the reserved
@@ -4328,6 +4482,10 @@ export class LSPService {
                                         : publishedEvidence
                                             ? "answered"
                                             : "silent";
+                                const elapsedMs = Date.now() - auxWaitStartedAt;
+                                if (outcome !== "deferred") {
+                                    this.noteAuxiliaryWait(`${aux.serverId}:${normalizeMapKey(aux.root)}`, budgetMs, elapsedMs);
+                                }
                                 return {
                                     serverId: aux.serverId,
                                     outcome,
@@ -4337,9 +4495,12 @@ export class LSPService {
                                     // did not narrow the touch.
                                     // #1586: through the one predicate, so this row and the merge
                                     // below cannot disagree about the same scanner.
+                                    // #2914: binding-only by construction — the direct call
+                                    // below is master's line; the stamp axis already decided
+                                    // the outcome above and must not re-admit the row here.
                                     publishedThisContent: auxCoversThisContent(aux.serverId),
                                     budgetMs,
-                                    elapsedMs: Date.now() - auxWaitStartedAt,
+                                    elapsedMs,
                                     // #1458 S3: elapsed measured from BEFORE the primary wait
                                     // (waitStartedAt), not just from auxWaitStartedAt — this is
                                     // what lets a latency row validate the ~1.3s warm-scanner
@@ -4372,7 +4533,9 @@ export class LSPService {
                             // revision and probing it would replay stale findings.
                             const collectLaterServerIds = outcomes
                                 .filter((o) => !o.publishedThisContent &&
-                                (o.outcome === "cut_off" || o.outcome === "silent") &&
+                                (o.outcome === "cut_off" ||
+                                    o.outcome === "silent" ||
+                                    o.outcome === "demoted") &&
                                 // #2324 R2-A/R3-A: ast-grep's napi fallback is a
                                 // SECOND producer of coverage for this exact pair,
                                 // dispatched CONCURRENTLY with this whole touch
@@ -4392,7 +4555,8 @@ export class LSPService {
                                     napiFallbackCoveredSince(filePath, startedAt)))
                                 .map((o) => o.serverId);
                             if (collectLaterServerIds.length > 0) {
-                                markPendingAuxiliaryCoverage(filePath, collectLaterServerIds);
+                                lateDeliveryServerIds = collectLaterServerIds;
+                                markPendingAuxiliaryCoverage(filePath, collectLaterServerIds, Date.now());
                             }
                             logLatency({
                                 type: "phase",
@@ -4592,9 +4756,11 @@ export class LSPService {
                         const outcomes = auxEntries.map((entry) => {
                             const baseline = diagnosticBaselines.get(entry.client);
                             const currentPathVersion = readPathVersion(entry.client);
-                            const publishedEvidence = Number.isFinite(baseline) &&
-                                currentPathVersion !== undefined &&
-                                currentPathVersion > baseline;
+                            const publishedEvidence = auxiliaryPublicationEvidence({
+                                bindingMatchesContent: false,
+                                baseline,
+                                currentPathVersion,
+                            });
                             return {
                                 serverId: entry.info.id,
                                 outcome: deferredResyncServerIds.has(entry.info.id)
@@ -4602,6 +4768,9 @@ export class LSPService {
                                     : publishedEvidence
                                         ? "answered"
                                         : "silent",
+                                // #2914: binding-only by construction — the direct call
+                                // below is master's line; the stamp axis already decided
+                                // the outcome above and must not re-admit the row here.
                                 publishedThisContent: auxCoversThisContent(entry.info.id),
                                 budgetMs: timeoutFor(entry.client.serverId),
                                 elapsedMs: waitedMs,
@@ -4866,7 +5035,7 @@ export class LSPService {
             // diagnostics from the client cache as always.
             let collected = options.collectDiagnostics
                 ? tsserverSyncConfirmed !== undefined
-                    ? mergeLspDiagnostics(tsserverSyncConfirmed)
+                    ? mergeLspDiagnostics(attributeDiagnostics(spawned[0]?.info.id ?? "unknown", tsserverSyncConfirmed))
                     : mergeLspDiagnostics([
                         // #1459: a DEFERRED server's cache still holds the PREVIOUS
                         // content's findings — the resync that would have cleared it never
@@ -4878,8 +5047,8 @@ export class LSPService {
                         // coverage naming and the merged binding read too.
                         ...spawned.flatMap((entry) => droppedAuxiliaryServerIds.has(entry.info.id)
                             ? []
-                            : entry.client.getDiagnostics(filePath)),
-                        ...carriedAuxiliary.flatMap((entry) => entry.diags),
+                            : attributeDiagnostics(entry.info.id, entry.client.getDiagnostics(filePath))),
+                        ...carriedAuxiliary.flatMap((entry) => attributeDiagnostics(entry.serverId, entry.diags)),
                     ])
                 : undefined;
             // #1095 (P3-b): whether `collected` came from a tsserver sync confirm
@@ -4919,7 +5088,9 @@ export class LSPService {
                         retractPrimaryTimeoutAttribution(); // #1549
                         syncConfirmed = true;
                         collected =
-                            syncResult.length > 0 ? mergeLspDiagnostics(syncResult) : [];
+                            syncResult.length > 0
+                                ? mergeLspDiagnostics(attributeDiagnostics(spawned[0]?.info.id ?? "unknown", syncResult))
+                                : [];
                         logLatency({
                             type: "phase",
                             phase: "lsp_tsserver_sync_confirm",
@@ -5252,9 +5423,11 @@ export class LSPService {
                 result.inconclusiveReason = verdict.inconclusiveReason;
             }
             else if (collected !== undefined && primaryDiagnosticsUnsupported) {
-                // A navigation-only primary has no diagnostic confirmation to report.
-                // Auxiliary coverage cannot turn that capability boundary into a clean
-                // or partial diagnostic verdict.
+                // A navigation-only primary has no diagnostic confirmation to report,
+                // but an uncovered auxiliary still needs to be named for delivery.
+                if (unconfirmedServerIds.length > 0) {
+                    result.unconfirmedServerIds = [...unconfirmedServerIds];
+                }
             }
             else if (collected !== undefined && coverageGap) {
                 // #1470/#1493: narrowed, not collapsed. Reached for EITHER no-answer
@@ -5312,6 +5485,17 @@ export class LSPService {
             // fully delivered. Nothing to record here: a skipped server keeps its original
             // entry (and timestamp) so its window still expires naturally instead of being
             // extended by every reuse.
+            // #2810: the half of the coverage gap that has a delivery path. Derived
+            // from `unconfirmedServerIds` so the two can never disagree about the
+            // same scanner, and intersected with the marked set so "findings will
+            // arrive through the late path" is said only where a pending pair
+            // exists. Everything else in the gap — a #1459 deferral, a breaker
+            // skip, an ast-grep already covered by its napi fallback — keeps the
+            // honest "silent, diagnostics are incomplete" half.
+            const lateDeliveryPending = unconfirmedServerIds.filter((serverId) => (lateDeliveryServerIds ?? []).includes(serverId));
+            if (lateDeliveryPending.length > 0) {
+                result.deferredServerIds = lateDeliveryPending;
+            }
             logLatency({
                 type: "phase",
                 phase: "lsp_touch_file",
@@ -5384,6 +5568,14 @@ export class LSPService {
                     ...(uncoveredDeferredServerIds.length > 0 && {
                         deferredResyncServerIds: uncoveredDeferredServerIds,
                     }),
+                    // #2810: the scanners this touch promised late delivery for, so a
+                    // field query can join the promise to the pending pair that has to
+                    // honour it — and tell it apart from `deferredResyncServerIds`
+                    // above, which is the door that opened BEFORE any wait and has no
+                    // delivery path at all.
+                    ...(lateDeliveryPending.length > 0 && {
+                        lateDeliveryServerIds: lateDeliveryPending,
+                    }),
                     // #1549: auxiliaries whose own deadline lapsed — the wait produced no
                     // publication, or the notify write never landed. Distinct from the fields
                     // above (a different door) and from `auxUnconfirmedServerIds` (derived
@@ -5620,7 +5812,7 @@ export class LSPService {
                 if (seen.has(key))
                     continue;
                 seen.add(key);
-                merged.push(diagnostic);
+                merged.push({ ...diagnostic, serverId: entry.serverId });
             }
         }
         const rawCount = perServerFull.reduce((sum, entry) => sum + entry.diagnosticCount, 0);
@@ -6788,6 +6980,42 @@ export class LSPService {
         const workspaceSweepScopeKey = buildScopeKey("all", [
             ...WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS,
         ]);
+        const touchScopedOpenDependencies = async (filePath) => {
+            if (options.files === undefined)
+                return true;
+            // Import coverage is language-neutral. Undefined means this file was
+            // not covered by the facts seam, so its cache entry is not eligible.
+            const imports = workspaceDiagnosticsCacheCtx.importsFor(filePath);
+            if (!imports)
+                return false;
+            const openImports = imports.filter((dependency) => this.hasLiveClientHoldingDocument(dependency));
+            const capped = openImports.length > SCOPED_DEPENDENCY_TOUCH_MAX;
+            if (capped) {
+                recordDegradationOnce({
+                    kind: "lsp_dependency_touch_capped",
+                    subject: filePath,
+                    reason: `scoped full scan limited open import touches to ${SCOPED_DEPENDENCY_TOUCH_MAX}`,
+                });
+            }
+            await Promise.all(openImports
+                .slice(0, SCOPED_DEPENDENCY_TOUCH_MAX)
+                .map(async (dependency) => {
+                let content;
+                try {
+                    content = await fs.readFile(dependency, "utf8");
+                }
+                catch {
+                    return;
+                }
+                await this.touchFile(dependency, content, {
+                    diagnostics: "none",
+                    source: "lens_diagnostics_full_dependency",
+                    clientScope: "all",
+                    excludeServerIds: await this.serverIdsNotHoldingDocument(dependency),
+                });
+            }));
+            return !capped;
+        };
         const cachedResults = [];
         const filesToTouch = [];
         const writeIndexByPath = new Map();
@@ -6804,18 +7032,22 @@ export class LSPService {
             // exists to detect) must NOT be replayed and reconciled as confirmed via
             // mode=full. On a mismatch, fall through to a fresh touch.
             if (cached && cached.binding.boundToCurrentDisk !== false) {
-                cachedResults.push({
-                    filePath,
-                    diagnostics: cached.diagnostics,
-                    count: cached.count,
-                    // #1093: a cache hit replays an older observation — carry its
-                    // scan time so mode=full's footer reconcile stamps `touchedAt`
-                    // with when the truth was seen, not now().
-                    observedAt: cached.scannedAt,
-                    contentHash: cached.binding.contentHash,
-                    boundToCurrentDisk: cached.binding.boundToCurrentDisk,
-                    writeIndex: writeIndexByPath.get(normalizeMapKey(filePath)),
-                });
+                const dependenciesConfirmed = await touchScopedOpenDependencies(filePath);
+                if (dependenciesConfirmed)
+                    cachedResults.push({
+                        filePath,
+                        diagnostics: cached.diagnostics,
+                        count: cached.count,
+                        // #1093: a cache hit replays an older observation — carry its
+                        // scan time so mode=full's footer reconcile stamps `touchedAt`
+                        // with when the truth was seen, not now().
+                        observedAt: cached.scannedAt,
+                        contentHash: cached.binding.contentHash,
+                        boundToCurrentDisk: cached.binding.boundToCurrentDisk,
+                        writeIndex: writeIndexByPath.get(normalizeMapKey(filePath)),
+                    });
+                else
+                    filesToTouch.push(filePath);
             }
             else {
                 filesToTouch.push(filePath);
@@ -7601,16 +7833,17 @@ export class LSPService {
             client.pruneDiagnostics((filePath, ts) => !existingPaths.has(filePath) || now - ts > CASCADE_DIAGNOSTICS_TTL_MS);
             const clientDiags = client.getAllDiagnostics();
             for (const [filePath, entry] of clientDiags) {
+                const attributed = attributeDiagnostics(client.serverId, entry.diags);
                 const existing = all.get(filePath);
                 if (existing) {
                     existing.diags = mergeLspDiagnostics([
                         ...existing.diags,
-                        ...entry.diags,
+                        ...attributed,
                     ]);
                     existing.ts = Math.max(existing.ts, entry.ts);
                 }
                 else {
-                    all.set(filePath, { diags: [...entry.diags], ts: entry.ts });
+                    all.set(filePath, { diags: attributed, ts: entry.ts });
                 }
                 const list = bindingsByPath.get(filePath) ?? [];
                 list.push(entry.binding);
@@ -7970,6 +8203,9 @@ export async function hasAuxiliaryLspPublishedForRoot(serverId, filePath) {
 export async function notifyExternalFileChange(filePath, type) {
     return getLSPService().notifyExternalFileChange(filePath, type);
 }
+export async function resyncGitChangedFiles(changedPaths) {
+    return getLSPService().resyncGitChangedFiles(changedPaths);
+}
 export function resetLSPService(options = {}) {
     // #2504 review round 2 (F3): whatever the retiring service was still being
     // asked for off-hook must stop HERE, before any teardown and before the