@herbertgao/pi-extensions 2026.8.7 → 2026.8.9

package/node_modules/pi-lens/dist/clients/lsp/cascade-tier.js

@@ -189,16 +189,41 @@ export function recordOutstandingCascadeTouch(entry) {
         });
     }
 }
-/** Test-only: clear the outstanding-touch registry between test cases. */
-export function _resetOutstandingCascadeTouchesForTests() {
+/**
+ * #1910: session-boundary reset for the outstanding-touch registry and its
+ * sweep-scoped `_expiredSinceLastSweep`/`_evictedSinceLastSweep` counters.
+ * Both predate #1899 and were never wired into `handleSessionStart` — a
+ * session replacement inherited the prior session's outstanding touches, and
+ * a stray eviction/expiry landing between a sweep and the boundary attributed
+ * its count to the NEXT session's first reconcile gauge. Wired primary-only,
+ * same as every other entry in that reset block: a concurrently-live
+ * secondary never reaches `handleSessionStart` at all (the #473 guard in
+ * index.ts), so it can never race this reset against the still-live
+ * primary's outstanding touches.
+ */
+export function resetCascadeTierSessionState() {
     _outstandingTouches.clear();
     _expiredSinceLastSweep = 0;
     _evictedSinceLastSweep = 0;
 }
+/** Test-only: clear the outstanding-touch registry between test cases. */
+export function _resetOutstandingCascadeTouchesForTests() {
+    resetCascadeTierSessionState();
+}
 /** Test-only: peek at the registry without mutating it. */
 export function _getOutstandingCascadeTouchesForTests() {
     return [..._outstandingTouches.values()];
 }
+/**
+ * Test-only: peek at the sweep-scoped expired/evicted counters without
+ * mutating them. Exists so a probe of `resetCascadeTierSessionState` can
+ * assert on THESE counters directly, rather than only on the registry map —
+ * a future counter added here and left out of the reset would otherwise
+ * stay invisible to any probe that only checks the map went empty.
+ */
+export function _getCascadeTierSweepCountersForTests() {
+    return { expired: _expiredSinceLastSweep, evicted: _evictedSinceLastSweep };
+}
 /**
  * Reconcile every outstanding Tier-3 touch against the LSP client's current
  * diagnostics cache. For each:

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

@@ -1422,6 +1422,41 @@ function setupConnectionLifecycle(state, recentStderr) {
             });
         }
     });
+    // #1969: the exit CAUSE, in the degradation ledger.
+    //
+    // The `exit` log above is one latency.log line per death. That line is
+    // necessary but not sufficient: an ast-grep child died 14 times in one day
+    // with `code=1` and empty stderr, and the only thing visible downstream was
+    // 19 `lsp_client_skipped_broken` cooldowns and 32 coverage gaps — fallout
+    // with no cause attached. The ledger is what a session-end health read
+    // looks at, so the cause belongs there too, counted per server.
+    //
+    // `close` rather than `exit`: `close` fires only after the child's stdio
+    // streams have drained, so "stderr was empty" is a statement about the
+    // server rather than a race against the pipe. `exit` can arrive first with
+    // stderr still buffered.
+    //
+    // Gated on `shutdownRequested` exactly as the exit log is — an eviction or
+    // an ordinary teardown is not a degradation and must not be recorded.
+    // `incrementDegradationCount` counts every occurrence and retains the
+    // latest reason per server, so a server dying in a loop shows as one entry
+    // with an honest count rather than N entries.
+    state.lspProcess.process.on("close", (code, signal) => {
+        if (state.shutdownRequested)
+            return;
+        try {
+            const stderrTail = recentStderr(20);
+            incrementDegradationCount({
+                kind: "lsp-server-unexpected-close",
+                subject: state.serverId,
+                reason: `closed unprompted: code=${code ?? "none"} signal=${signal ?? "none"} ` +
+                    `stderr=${stderrTail.length > 0 ? `present(${stderrTail.length}b)` : "empty"} root=${state.root}`,
+            });
+        }
+        catch {
+            // Telemetry must never break the observed path.
+        }
+    });
 }
 /** Margin between each source's own request timeout and the race's backstop
  *  deadline, so the natural "all sources settled" path wins over the backstop
@@ -2750,13 +2785,85 @@ function armNavLateAnswerTelemetry(args) {
         // as an unhandled rejection.
     });
 }
+/**
+ * #1969: pick the request the liveness probe may send to THIS server.
+ *
+ * The probe only needs a round-trip, so any request works — but it must be one
+ * the server advertised. #1277 originally hardcoded `workspace/symbol` because
+ * it needs no open document, and treated `MethodNotFound` as proof of life.
+ * That rationale is sound for the round-trip, and wrong as a default: a server
+ * that does not implement the method logs an error for every probe. ast-grep's
+ * tower_lsp backend wrote "got a 'workspace/symbol' request, but it is not
+ * implemented" on each one, and its `code=1` deaths clustered after them
+ * (#1969). pi-lens must not keep pushing an unimplemented method at a server
+ * just to learn it is awake.
+ *
+ * The ladder, best first:
+ *  1. `workspace/symbol` when `workspaceSymbolProvider` is advertised — the
+ *     #1277 probe, unchanged, and still needs no open document.
+ *  2. `textDocument/documentSymbol` on an already-open document when
+ *     `documentSymbolProvider` is advertised. Read-only, scoped to a document
+ *     the server already has, and cheap.
+ *  3. `textDocument/hover` at the start of an already-open document when
+ *     `hoverProvider` is advertised. This step is what keeps ast-grep covered:
+ *     `docs/servercapabilities.md:53` records its advertised set as
+ *     codeActionProvider, executeCommandProvider, hoverProvider and
+ *     textDocumentSync — no symbol provider of either kind. #1714's own
+ *     measurement (clients/lsp/index.ts, `paceAuxNotify`) timed hover against
+ *     the real ast-grep binary at 1 ms idle and 2086 ms behind 30 `didOpen`s,
+ *     the same ordering proof it recorded for `workspace/symbol`. So the
+ *     notify throttle keeps a real barrier here, not a hollow one.
+ *  4. Nothing. The caller then reports liveness from process and connection
+ *     state alone, and records that it did.
+ *
+ * `MethodNotFound`-counts-as-alive still holds for every probe: dynamic
+ * registration can retract a capability after `initialize`, and an error reply
+ * is still a reply. What changes is that pi-lens no longer PROVOKES that error
+ * on every probe.
+ */
+function chooseLivenessProbe(state) {
+    if (state.operationSupport?.workspaceSymbol === true) {
+        return {
+            method: "workspace/symbol",
+            params: { query: LIVENESS_PING_QUERY },
+        };
+    }
+    const openUri = firstOpenDocumentUri(state);
+    if (openUri === undefined)
+        return undefined;
+    if (state.operationSupport?.documentSymbol === true) {
+        return {
+            method: "textDocument/documentSymbol",
+            params: { textDocument: { uri: openUri } },
+        };
+    }
+    if (state.operationSupport?.hover === true) {
+        return {
+            method: "textDocument/hover",
+            params: {
+                textDocument: { uri: openUri },
+                position: { line: 0, character: 0 },
+            },
+        };
+    }
+    return undefined;
+}
+/** URI of any document this client currently holds open, if it holds one. */
+function firstOpenDocumentUri(state) {
+    for (const normalizedPath of state.openDocuments) {
+        const uri = state.openDocumentUris?.get(normalizedPath);
+        if (uri !== undefined)
+            return uri;
+    }
+    return undefined;
+}
 // #1277: cheap liveness round-trip used by the silent-clean gates in
 // `index.ts`. `isAlive()`/`checkAlive()` only look at process/connection
 // state — a server that accepted the notify write and then wedged (still
 // running, connection still open, just never replying) reads as "alive" by
 // those checks even though it will never answer anything again. This sends a
-// real request (`workspace/symbol`, chosen because it needs no open document)
-// and reports whether the connection round-tripped it — success, a genuine
+// real request (see `chooseLivenessProbe` for which, #1969) and reports
+// whether the connection round-tripped it — success, a genuine
 // protocol-level error (e.g. MethodNotFound), and a stream-destroyed/
 // cancelled response (safeSendRequest swallows those to `undefined`, so the
 // final `isClientAlive` re-check is what catches "died mid-flight") ALL count
@@ -2766,10 +2873,30 @@ function armNavLateAnswerTelemetry(args) {
 async function clientPingLiveness(state, timeoutMs = LIVENESS_PING_TIMEOUT_MS) {
     if (!isClientAlive(state))
         return false;
+    const probe = chooseLivenessProbe(state);
+    if (probe === undefined) {
+        // #1969: no advertised method to probe with, so this answer comes from
+        // process and connection state alone — exactly the checks the probe
+        // exists to strengthen. Say so in the ledger rather than let a weaker
+        // verdict pass as the strong one. Rising edge per server, via the
+        // ledger's own tally; the count carries the repeats.
+        try {
+            incrementDegradationCount({
+                kind: "lsp-liveness-probe-unsupported",
+                subject: state.serverId,
+                reason: "no advertised request method to probe with (no " +
+                    "workspaceSymbolProvider, and no open document with " +
+                    "documentSymbolProvider or hoverProvider); liveness from " +
+                    "process and connection state only",
+            });
+        }
+        catch {
+            // Telemetry must never break the observed path.
+        }
+        return isClientAlive(state);
+    }
     try {
-        await withTimeout(safeSendRequest(state.connection, "workspace/symbol", {
-            query: LIVENESS_PING_QUERY,
-        }), timeoutMs);
+        await withTimeout(safeSendRequest(state.connection, probe.method, probe.params), timeoutMs);
     }
     catch (err) {
         if (err instanceof Error && err.message.startsWith("Timeout after")) {
@@ -3134,6 +3261,18 @@ export async function createLSPClient(options) {
         }), initializeTimeoutMs);
     }
     catch (err) {
+        // #1969: claim this kill BEFORE issuing it. `setupConnectionLifecycle`
+        // ran above, so its `exit` and `close` handlers are already armed on
+        // this child, and both read `state.shutdownRequested` to tell a crash
+        // from a teardown we asked for. The kill below is one we asked for.
+        // Without this line it reported as an unprompted death, fabricating a
+        // `lsp-server-unexpected-close` entry reading
+        // "code=1 signal=none stderr=empty" — character for character the
+        // ast-grep signature this issue exists to make trustworthy — every time
+        // a server merely failed to complete its handshake. It also silenced a
+        // false `lsp_server_unexpected_exit` latency line that this path has
+        // been writing since the #615 follow-up.
+        state.shutdownRequested = true;
         // Hard-kill the hung process so it doesn't become a zombie.
         // SIGTERM alone is unreliable on Windows for cmd.exe/PowerShell trees.
         const pid = lspProcess.pid;

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

@@ -555,9 +555,15 @@ async function collectWorkspaceDiagnosticFiles(root, maxFiles = getMaxWorkspaceD
                     continue;
                 await walk(full);
             }
-            else if (entry.isFile() &&
-                !ignoreMatcher.isIgnored(full, false) &&
-                getServersForFileWithConfig(full).length > 0) {
+            else if (
+            // #1974: the getServersForFileWithConfig lookup (an in-memory
+            // extension/pathFilter match against the registered LSP servers) is
+            // cheap relative to isIgnored's per-call minimatch pattern compile,
+            // so it gates first — the same order-independent shape as the four
+            // walkers fixed for #1974.
+            entry.isFile() &&
+                getServersForFileWithConfig(full).length > 0 &&
+                !ignoreMatcher.isIgnored(full, false)) {
                 files.push(full);
             }
         }
@@ -576,6 +582,21 @@ export class LSPService {
     /** Server/root pairs that already emitted unavailable for the current occurrence. */
     unavailableLogged = new Set();
     optionalDisabled = new Set();
+    /**
+     * #1934 review F1: what the last COMPLETED `spawnClient` call for a
+     * (server, root) key decided, written by that call at every point it
+     * returns without a client. This is a direct signal, deliberately NOT an
+     * inference from breaker state: the "binary unavailable while installs are
+     * disabled" branch sets a cooldown yet is a POLICY decline by its own
+     * comment, so reading the cooldown mislabels it as a server failure.
+     *
+     * Not a latch, and nothing re-arms it at `session_start`. Every read sits
+     * in the same microtask as the `await` of the spawn promise that just
+     * wrote it, so a stale entry is unreachable: a read is always preceded by
+     * its own attempt's write. Cardinality matches `state.clients` — one entry
+     * per (server, root) — and a successful spawn deletes its entry.
+     */
+    lastSpawnVerdict = new Map();
     /** Consecutive failure counts for exponential backoff circuit breaker */
     failureCounts = new Map();
     /**
@@ -1589,9 +1610,20 @@ export class LSPService {
         const withBudget = async () => {
             if (servers.length === 0)
                 return undefined;
+            // #1934: the first server whose acquisition ERRORED, as opposed to
+            // cleanly declining. Kept so a selection that served nobody still
+            // says which server the pool actually tried and failed to spawn.
+            let erroredServerId;
             // Try each matching server
             for (const server of servers) {
-                const spawned = await this.ensureClientForServer(filePath, server, resolvedRoots, noteSpawnInFlight);
+                // A box, not a `let`: control-flow analysis cannot see the callback
+                // write and would narrow a plain local to its initializer.
+                const acquisition = {
+                    outcome: "declined",
+                };
+                const spawned = await this.ensureClientForServer(filePath, server, resolvedRoots, noteSpawnInFlight, (reported) => {
+                    acquisition.outcome = reported;
+                });
                 if (spawned) {
                     logLatency({
                         type: "phase",
@@ -1601,10 +1633,36 @@ export class LSPService {
                         metadata: {
                             serverId: server.id,
                             candidateCount: servers.length,
+                            // Emitted RAW, never coerced to a "safe" value: a served
+                            // client always reports `warm-reuse` or `cold-spawn`, so a
+                            // `declined` here would be a real reporting bug and must be
+                            // visible in the log rather than laundered into a lie.
+                            outcome: acquisition.outcome,
                         },
                     });
                     return spawned;
                 }
+                if (acquisition.outcome === "spawn-failure") {
+                    erroredServerId ??= server.id;
+                }
+            }
+            if (erroredServerId !== undefined) {
+                // Same record, same denominator as the two served outcomes. Bounded
+                // by the LSP breaker, not by a latch: a spawn failure always cools
+                // the (server, root) key down, so the next touch takes the
+                // `lsp_client_skipped_broken` early return and reports `declined`
+                // instead of reaching here again until the cooldown expires.
+                logLatency({
+                    type: "phase",
+                    phase: "lsp_client_selected",
+                    filePath,
+                    durationMs: 0,
+                    metadata: {
+                        serverId: erroredServerId,
+                        candidateCount: servers.length,
+                        outcome: "spawn-failure",
+                    },
+                });
             }
             const unavailable = (await Promise.all(servers.map(async (server) => {
                 const root = await server.root(filePath);
@@ -1753,6 +1811,10 @@ export class LSPService {
         if (this.checkDestroyed())
             return undefined;
         const servers = getServersForFileWithConfig(filePath);
+        // #1934: the (server, root) pairs that COULD have served this file and
+        // were cold. A server with no resolvable root is not a pool miss — it
+        // never had a slot to miss — so it stays out of this list.
+        const missed = [];
         for (const server of servers) {
             const root = await this.resolveServerRoot(server, filePath);
             if (!root)
@@ -1762,6 +1824,27 @@ export class LSPService {
             if (existing?.isAlive()) {
                 return { client: existing, info: server };
             }
+            missed.push(key);
+        }
+        // #1934: an empty `missed` means "this file has no language server here",
+        // which is the normal answer for most reads and must not be logged as a
+        // pool miss. Callers run per file in the cascade quiet window and on the
+        // read-expansion path, so a raw record would be a per-file log storm:
+        // the ledger counts every miss exactly and only the FIRST per candidate
+        // set also writes the detailed record.
+        if (missed.length > 0) {
+            emitBounded("lsp_warm_client_missing", missed.join(","), {
+                filePath,
+                durationMs: 0,
+                metadata: {
+                    serverIds: missed.map((key) => key.slice(0, key.indexOf(":"))),
+                    roots: missed.map((key) => key.slice(key.indexOf(":") + 1)),
+                },
+            }, {
+                ledgerKind: "lsp-warm-client-missing",
+                risingEdgePer: "identity",
+                reason: `no warm client for ${missed.join(",")}`,
+            });
         }
         return undefined;
     }
@@ -1972,7 +2055,22 @@ export class LSPService {
         }
         this.documentDrift.recordSynced(filePath, content, at);
     }
-    async ensureClientForServer(filePath, server, resolvedRoots, onSpawnInFlight) {
+    /**
+     * #1934 review F1: record what a `spawnClient` call decided, at the point
+     * it decides it. Called on EVERY path that returns without a client, so
+     * "no verdict" cannot silently mean "failed".
+     *
+     * `"failed"` is a server failure: the spawn or the initialize handshake
+     * went wrong. `"declined"` is policy or lifecycle: host trust refused the
+     * binary, the service shut down mid-spawn, or the binary is absent while
+     * installs are disabled. That last one sets a breaker cooldown but is NOT
+     * a failure, which is exactly why the outcome cannot be inferred from
+     * breaker state.
+     */
+    noteSpawnVerdict(key, verdict) {
+        this.lastSpawnVerdict.set(key, verdict);
+    }
+    async ensureClientForServer(filePath, server, resolvedRoots, onSpawnInFlight, onOutcome) {
         const handoff = this.generationHandoff;
         if (handoff) {
             await handoff;
@@ -2043,6 +2141,10 @@ export class LSPService {
                     logSessionStart(`lsp warm-start ${server.id}: reused root=${root} file=${filePath}`);
                     this.warmStartLogged.add(key);
                 }
+                // #1934: the pool paid nothing. This is the outcome the reuse rate
+                // is built from, so it is reported on the ONE path that returns a
+                // client without spawning.
+                onOutcome?.("warm-reuse");
                 return { client: existing, info: server };
             }
             // Dead client — was previously alive, now needs respawn
@@ -2269,7 +2371,24 @@ export class LSPService {
         // which strands the settled promise and stops the server respawning.
         onSpawnInFlight?.(server.id);
         try {
-            return await spawnPromise;
+            const spawned = await spawnPromise;
+            // #1934: a client here cost a process WAIT, whether this caller
+            // started the spawn or joined another caller's in-flight promise.
+            // Either way the selection was not served from the warm pool.
+            //
+            // The verdict read is synchronous and sits in the same microtask as
+            // the await above, so it can only see the attempt just settled.
+            onOutcome?.(spawned
+                ? "cold-spawn"
+                : this.lastSpawnVerdict.get(key) === "failed"
+                    ? "spawn-failure"
+                    : "declined");
+            return spawned;
+        }
+        catch (err) {
+            // A throwing spawn promise is an errored acquisition by definition.
+            onOutcome?.("spawn-failure");
+            throw err;
         }
         finally {
             if (this.state.inFlight.get(key) === spawnPromise) {
@@ -2293,6 +2412,7 @@ export class LSPService {
         // failure, and the user may grant trust later in the same session.
         if (!isLspSpawnAllowedByTrust()) {
             logSessionStart(`lsp spawn ${server.id}: refused — ${projectTrustDenialReason()}`);
+            this.noteSpawnVerdict(key, "declined");
             return undefined;
         }
         const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id); // NOSONAR: set intentionally empty — no optional servers configured yet
@@ -2312,6 +2432,7 @@ export class LSPService {
                     // pi-lens-ignore: missing-error-propagation — best-effort kill on aborted spawn
                 }
                 logSessionStart(`lsp spawn ${server.id}: aborted (service shut down mid-spawn)`);
+                this.noteSpawnVerdict(key, "declined");
                 return undefined;
             }
             if (!spawned) {
@@ -2325,6 +2446,17 @@ export class LSPService {
                 if (!allowInstall) {
                     logSessionStart(`lsp spawn ${server.id}: unavailable with install disabled; temporary cooldown only`);
                     this.state.broken.set(key, Date.now() + BROKEN_BASE_COOLDOWN_MS);
+                    // #1934 review F1: this branch sets a cooldown but is a POLICY
+                    // decline by the comment above — the binary may appear on PATH
+                    // later in the same session, so it never counts toward permanent
+                    // disablement and the cooldown has no ladder. With installs
+                    // disabled or a project untrusted, a missing binary reaches here
+                    // once per 15s per (server, root) for the whole session. Calling
+                    // that a spawn failure would write thousands of mislabeled
+                    // records a day, so it reads as a decline. The event is already
+                    // recorded once by `lsp_client_unavailable` and by the
+                    // `sessionstart.log` line above.
+                    this.noteSpawnVerdict(key, "declined");
                     return undefined;
                 }
                 const uCount = (this.failureCounts.get(key) ?? 0) + 1;
@@ -2336,6 +2468,9 @@ export class LSPService {
                     this.recordBreaker(key, `permanently disabled after ${uCount} unavailable spawns`);
                     logSessionStart(`lsp spawn ${server.id}: permanently disabled after ${uCount} failures`);
                 }
+                // Installs were allowed and the server is still unavailable: a real
+                // failure, on the exponential ladder toward permanent disablement.
+                this.noteSpawnVerdict(key, "failed");
                 return undefined;
             }
             const override = getServerInitOverride(server.id, filePath);
@@ -2353,6 +2488,7 @@ export class LSPService {
             if (this.isDestroyed) {
                 client.shutdown({ fast: true }).catch(() => { });
                 logSessionStart(`lsp spawn ${server.id}: aborted (service shut down mid-initialize)`);
+                this.noteSpawnVerdict(key, "declined");
                 return undefined;
             }
             const wsDiag = typeof client.getWorkspaceDiagnosticsSupport === "function"
@@ -2364,6 +2500,9 @@ export class LSPService {
                 };
             this.state.clients.set(key, client);
             this.unavailableLogged.delete(key);
+            // #1934 review F1: a success retires the previous verdict, so the map
+            // never outlives the attempts it describes.
+            this.lastSpawnVerdict.delete(key);
             this.state.clientSpawnedAt.set(key, Date.now());
             this.clientLastUsedAt.set(key, Date.now());
             this.scheduleTypeScriptIdleEviction(key);
@@ -2404,6 +2543,8 @@ export class LSPService {
             if (isOptionalServer) {
                 this.optionalDisabled.add(key);
             }
+            // The spawn or the initialize handshake threw: a server failure.
+            this.noteSpawnVerdict(key, "failed");
             return undefined;
         }
     }
@@ -6479,6 +6620,10 @@ export class LSPService {
         });
         this.state.clients.clear();
         this.state.broken.clear();
+        // #1934 review F1: map hygiene alongside the breaker it sits next to.
+        // Not load-bearing — every read follows its own attempt's write — but a
+        // verdict for a client generation that no longer exists is dead weight.
+        this.lastSpawnVerdict.clear();
         // #1459: every gated client is gone, so no outstanding-write record can
         // describe a live one. The gate's identity check already neutralises a stale
         // entry; clearing keeps the map honest rather than relying on that.

package/node_modules/pi-lens/dist/clients/module-report.js

@@ -1338,10 +1338,19 @@ export async function moduleReport(file, cwd, options) {
     let graph;
     let graphFileCap;
     let callGraphIdentity;
+    // #1961 review F4: the blind read now serves a snapshot stamped at a
+    // different commit. project_report says so in its trust notes; this report
+    // reads through the SAME accessor, so without this it would present the
+    // other branch's importers and call edges as current, under a builtAt that
+    // looks fresh. Computed per call, never cached.
+    let revisionDriftNote;
     try {
-        const { getCachedReviewGraph, getReviewGraphCacheIdentity, getReviewGraphSizeSkipVerdict, } = await import("./review-graph/builder.js");
+        const { getCachedReviewGraph, getReviewGraphCacheIdentity, getReviewGraphSizeSkipVerdict, getReviewGraphRevisionDrift, formatReviewGraphRevisionDriftNote, } = await import("./review-graph/builder.js");
         graph = getCachedReviewGraph(cwd);
         graphFileCap = getReviewGraphSizeSkipVerdict(cwd)?.maxFileCount;
+        const drift = graph ? getReviewGraphRevisionDrift(cwd) : undefined;
+        if (drift)
+            revisionDriftNote = formatReviewGraphRevisionDriftNote(drift);
         callGraphIdentity = graph
             ? (() => {
                 const identity = getReviewGraphCacheIdentity(cwd, graph);
@@ -1374,6 +1383,10 @@ export async function moduleReport(file, cwd, options) {
     const api = topLevel.filter((entry) => entry.exported);
     const internal = topLevel.filter((entry) => !entry.exported);
     const warnings = [...(extractionWarnings ?? [])];
+    // Every graph-derived section below (who-uses-this, blast radius, call
+    // edges) came from the served snapshot, so the caveat belongs with them.
+    if (revisionDriftNote)
+        warnings.push(revisionDriftNote);
     if (callbackError) {
         warnings.push(`Failed to extract callbacks: ${callbackError}`);
         logLatency({