@herbertgao/pi-extensions 2026.9.0 → 2026.9.2

package/node_modules/pi-lens/dist/clients/lens-flag-registry.js

@@ -17,6 +17,7 @@
  * `~/.pi-lens/config.json`. Adding a toggle means adding one entry here; there
  * is no second place to remember.
  */
+import { DEPRECATED_CONFIG_SURFACES } from "./config-diagnostic-codes.js";
 export const LENS_FLAGS = [
     {
         name: "no-lens",
@@ -188,6 +189,22 @@ export const LENS_FLAGS = [
         default: false,
         scope: "global",
     },
+    ...[
+        "knip",
+        "jscpd",
+        "madge",
+        "gitleaks",
+        "govulncheck",
+        "deadCode",
+        "complexity",
+    ].map((analyzer) => ({
+        name: `no-${analyzer.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}`,
+        description: `Disable the ${analyzer} session-start analyzer. Also via ${analyzer}.enabled=false in config.`,
+        configKey: `${analyzer}.enabled`,
+        negated: true,
+        default: false,
+        scope: "project",
+    })),
 ];
 const byName = new Map(LENS_FLAGS.map((spec) => [spec.name, spec]));
 export function getLensFlagSpec(name) {
@@ -215,25 +232,79 @@ export const GLOBAL_NON_FLAG_CONFIG_SECTIONS = [
     "ignore",
     "dispatch",
     "widget",
+    "startup",
     "$schema",
 ];
+/**
+ * Recognized TOP-LEVEL sections of a project `.pi-lens.json` that are NOT
+ * derived from the flag registry — the project loader's own hand-parsed
+ * sections (`ignore`, `rules`, `maxProjectFiles`, `reviewGraph`) plus the two
+ * namespaces another pi-lens runner reads off `PiLensProjectConfig.raw`
+ * (`trivy` in `trivy-client.ts`, `helm.renderValidation.enabled` in the
+ * helm-render runner, #1283).
+ *
+ * Moved here from `project-lens-config.ts` by #2426 so the canonical schema in
+ * `config-schema.ts` derives its namespace list from ONE place instead of
+ * importing the project loader (which would close an import cycle, since that
+ * loader now resolves through the schema).
+ */
+export const PROJECT_NON_FLAG_CONFIG_SECTIONS = [
+    "ignore",
+    "rules",
+    "maxProjectFiles",
+    "reviewGraph",
+    "trivy",
+    "helm",
+    "startup",
+];
+/**
+ * The four LSP settings a PROJECT config file may carry — at its root during
+ * the deprecation window, and under `lsp` canonically. DERIVED from the
+ * registry's `kind: "key"` rows so the accepted set and the removal schedule
+ * cannot drift apart, and named once because two places below need it.
+ */
+const LSP_PROJECT_HONORED_KEYS = DEPRECATED_CONFIG_SURFACES.filter((row) => row.kind === "key").map((row) => row.surface);
 /**
  * Foreign top-level namespaces that legitimately appear in a SHARED
  * `.pi-lens.json` but belong to a DIFFERENT loader: the LSP config loader
- * (`clients/lsp/config.ts`) reads `servers` / `serverOverrides` /
- * `disabledServers` / `warmFiles` out of the very same file. The project-lens
+ * (`clients/lsp/config.ts`) reads the `lsp` namespace — and, for its
+ * deprecation window, the legacy ROOT keys `servers` / `serverOverrides` /
+ * `disabledServers` / `warmFiles` — out of the very same file. The project-lens
  * loader must TOLERATE these (never warn "unknown key") — they are not typos,
  * just another subsystem's namespace. `$schema` is allowed for editor
  * JSON-schema association. Declared once, here, for the same #883 reason as
  * {@link GLOBAL_NON_FLAG_CONFIG_SECTIONS}.
+ *
+ * `lsp` joined this list in #2426: it is the canonical home of the four legacy
+ * keys beside it, so a project config that has already been migrated must not
+ * be told its `lsp` section is a global-only setting. Its tolerance is
+ * SUB-KEY-SCOPED — see {@link PROJECT_FOREIGN_NAMESPACE_HONORED_KEYS}.
  */
 export const PROJECT_FOREIGN_CONFIG_NAMESPACES = [
-    "servers",
-    "serverOverrides",
-    "disabledServers",
-    "warmFiles",
+    "lsp",
+    // DERIVED, not restated: the four legacy root keys are exactly the
+    // `kind: "key"` rows of the deprecation registry, and a hand-copied second
+    // list of them would be a place for the accepted set and the removal
+    // schedule to drift apart. `config-diagnostic-codes.ts` is a dependency-free
+    // data leaf, so importing it keeps this module's own no-cycle property.
+    ...LSP_PROJECT_HONORED_KEYS,
     "$schema",
 ];
+/**
+ * For a foreign namespace whose PROJECT-honored surface is only PART of what
+ * the namespace can hold: which sub-keys a `.pi-lens.json` may set.
+ *
+ * `lsp` is tolerated at the top level because the LSP loader reads it out of
+ * this same file — but only four of its keys are project-scoped. `lsp.enabled`
+ * is a `scope: "global"` flag (`--no-lsp`), so blanket namespace tolerance made
+ * a project-file `lsp.enabled: false` do nothing with no signal at all, where
+ * before #2426 the user got the honest "global-only setting" notice
+ * (#2426 review round 2, F3). `docs/configuration.md` promises that nothing
+ * about a config is ignored silently, so the namespace is tolerated KEY BY KEY
+ * and anything else under it is scanned by the same global-only-vs-typo rules a
+ * top-level key gets.
+ */
+export const PROJECT_FOREIGN_NAMESPACE_HONORED_KEYS = new Map([["lsp", LSP_PROJECT_HONORED_KEYS]]);
 /**
  * The distinct TOP-LEVEL section keys a set of flags lives under (the first
  * dotted segment of each `configKey`). Both config loaders derive their

package/node_modules/pi-lens/dist/clients/lens-map.js

@@ -24,7 +24,7 @@ import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
 import { canonicalSourceTwin } from "./source-filter.js";
 import { buildOrUpdateGraph } from "./review-graph/service.js";
 import { detectFileRole } from "./file-role.js";
-export const DEFAULT_MAX_MAP_NODES = 500;
+const DEFAULT_MAX_MAP_NODES = 500;
 /**
  * Aggregates a symbol-level {@link ReviewGraph} into file-level nodes/edges.
  * Pure and side-effect-free — no graph build here, no filesystem access — so

package/node_modules/pi-lens/dist/clients/log-cleanup.js

@@ -22,10 +22,10 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getGlobalPiLensDir } from "./file-utils.js";
+import { getGlobalPiLensLogDir } from "./probe-home-state.js";
 import { getRegisteredLogFiles } from "./ndjson-logger.js";
 import { pathsEqual } from "./path-utils.js";
-const LOG_DIR = getGlobalPiLensDir();
+const LOG_DIR = getGlobalPiLensLogDir();
 const LOGS_SUBDIR = path.join(LOG_DIR, "logs");
 /**
  * Every global `.log` pi-lens writes under ~/.pi-lens, resolved dynamically so
@@ -220,39 +220,3 @@ export function runLogCleanup(dbg) {
     }
     return results;
 }
-/**
- * Get current log storage summary
- */
-export function getLogStorageSummary() {
-    const files = [];
-    let totalMB = 0;
-    // Main logs
-    for (const name of getManagedLogFiles()) {
-        const filePath = path.join(LOG_DIR, name);
-        if (fs.existsSync(filePath)) {
-            const sizeMB = getFileSizeMB(filePath);
-            const ageDays = getFileAgeDays(filePath);
-            files.push({ name, sizeMB, ageDays });
-            totalMB += sizeMB;
-        }
-    }
-    // Daily logs
-    try {
-        if (fs.existsSync(LOGS_SUBDIR)) {
-            const dailyFiles = fs.readdirSync(LOGS_SUBDIR);
-            for (const name of dailyFiles) {
-                if (!name.endsWith(".jsonl"))
-                    continue;
-                const filePath = path.join(LOGS_SUBDIR, name);
-                const sizeMB = getFileSizeMB(filePath);
-                const ageDays = getFileAgeDays(filePath);
-                files.push({ name: `logs/${name}`, sizeMB, ageDays });
-                totalMB += sizeMB;
-            }
-        }
-    }
-    catch {
-        // Ignore
-    }
-    return { totalMB, files };
-}

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

@@ -34,7 +34,9 @@
  *   `PromiseDescriptor.budgetMs`.
  */
 export async function raceToCompletion(promises, shouldComplete, options = { timeoutMs: 1500 }) {
-    const results = new Array(promises.length).fill(undefined);
+    const results = [];
+    results.length = promises.length;
+    results.fill(undefined);
     let graceTimer;
     let auxGraceTimer;
     let completed = false;

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

@@ -730,7 +730,7 @@ function retirePullSource(state, identifier) {
     for (const source of [state.pullResultIds, state.pullRequestSequences]) {
         if (!source)
             continue;
-        for (const key of [...source.keys()]) {
+        for (const key of source.keys()) {
             if (key.endsWith(suffix))
                 source.delete(key);
         }
@@ -947,7 +947,7 @@ function scanSentContent(content) {
  * read on the notification path (I1). Bounded by the same file-size gates the
  * caller already applies to the content it hands us.
  */
-function recordSentContent(state, normalizedPath, version, content) {
+function recordSentContent(state, normalizedPath, version, content, coalescedCount = 0) {
     const scan = scanSentContent(content);
     const previous = state.documentContentHashes.get(normalizedPath);
     if (previous && previous.version > version) {
@@ -1049,6 +1049,7 @@ function recordSentContent(state, normalizedPath, version, content) {
             version,
             contentLength: content.length,
             contentLineCount: scan.lfNewlineCount + 1,
+            ...(coalescedCount > 0 && { coalescedCount }),
         },
     });
 }
@@ -1172,7 +1173,7 @@ export function resolveConfigurationSection(initialization, section) {
 // Exported (only) so tests can invoke the publishDiagnostics notification
 // handler directly against a mock LSPClientState/connection without spawning
 // a real language server. Not part of the public client API surface.
-export function setupIncomingHandlers(state, initialization) {
+export function setupIncomingHandlers(state, initialization, onDiagnosticsPublished) {
     state.connection.onNotification("textDocument/publishDiagnostics", (params) => {
         // #1639: the settle operation's own clock for THIS publish. A
         // "quiet-window" settle's durationMs below measures from here (when
@@ -1187,6 +1188,7 @@ export function setupIncomingHandlers(state, initialization) {
         // that is no longer open on this client.
         if (state.closedDocuments?.has(normalizedPath))
             return;
+        onDiagnosticsPublished?.(state.serverId);
         const newDiags = normalizeLspDiagnostics(params.diagnostics || []);
         const docVersion = params.version;
         if (PUB_DEBUG) {
@@ -1423,14 +1425,33 @@ export function setupIncomingHandlers(state, initialization) {
         if (state.serverEditsAllowed <= 0 || !params?.edit) {
             return { applied: false, failureReason: "edit not solicited" };
         }
-        const context = (state.activeMutationDepth ?? 0) === 1
-            ? state.activeMutationContext
-            : undefined;
+        // #2450 fix round 3 (F3) removed a `depth === 1` re-check here as
+        // dead code. It is not dead — it moved to the WRITE side, where it
+        // is the live invariant: `state.activeMutationContext` is assigned
+        // only by `syncMutationContextSlot` (below in this file), which
+        // populates it exactly when `activeMutationDepth === 1` and
+        // empties it on every other frame transition. The depth test
+        // therefore still runs, on each entry and each unwind; repeating
+        // it here would be a second copy of the same predicate, not an
+        // independent gate. What this handler reads is consequently either
+        // the context of the single frame currently in flight or
+        // `undefined` — never a settled frame's context, and never a
+        // context belonging to some other window that is still open
+        // (#2479 review rounds 2/3).
+        const context = state.activeMutationContext;
+        // `workspace/applyEdit` is only ever honored inside the
+        // `serverEditsAllowed` window this handler just checked, which is
+        // opened exclusively by an executeCommand call — so a fallback here is
+        // always executeCommand-solicited, never a bare edit (#2450). This
+        // fallback context carries no runtime/cacheManager (there is no live
+        // reference to those singletons at this call site); lsp-mutation.ts's
+        // bookkeepLspMutation falls back to the mutation bridge for exactly
+        // that reason rather than silently dropping the write's bookkeeping.
         const telemetryContext = context ?? {
             cwd: state.root,
             correlationId: newLspMutationCorrelationId(),
             tool: "lsp-workspace-applyEdit",
-            source: "lsp-edit",
+            source: "lsp-execute-command",
         };
         try {
             await applyWorkspaceEdit(params.edit, state.root, {
@@ -2430,7 +2451,7 @@ export function handleNotifyExternalChange(state, filePath, type) {
     const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
     state.watchQueue.enqueue(uri, type);
 }
-export async function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false) {
+async function handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0) {
     if (!isClientAlive(state))
         return;
     const normalizedPath = normalizeMapKey(filePath);
@@ -2478,7 +2499,7 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
             // #1669 review F7: only mirror the send locally once it actually left
             // the process — see safeSendNotification's doc comment.
             if (reopenSent)
-                recordSentContent(state, normalizedPath, version, content);
+                recordSentContent(state, normalizedPath, version, content, coalescedCount);
             state.openDocuments.add(normalizedPath);
             state.openDocumentUris?.set(normalizedPath, uri);
             return;
@@ -2488,7 +2509,7 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
             contentChanges: buildContentChanges(state, normalizedPath, content),
         });
         if (changeSent)
-            recordSentContent(state, normalizedPath, version, content);
+            recordSentContent(state, normalizedPath, version, content, coalescedCount);
         return;
     }
     state.pendingOpens.add(normalizedPath);
@@ -2523,7 +2544,7 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
         return;
     const openSent = await safeSendNotification(state.connection, "textDocument/didOpen", { textDocument: { uri, languageId, version: 0, text: content } });
     if (openSent)
-        recordSentContent(state, normalizedPath, 0, content);
+        recordSentContent(state, normalizedPath, 0, content, coalescedCount);
     state.pendingOpens.delete(normalizedPath);
     state.openDocuments.add(normalizedPath);
     state.closedDocuments?.delete(normalizedPath);
@@ -2547,7 +2568,81 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
         },
     });
 }
-async function handleNotifyChangeOnce(state, filePath, content, normalizedPath) {
+/**
+ * Replace only notifications that have not started a transport write. A
+ * microtask starts the first entry so a synchronous burst of callers installs
+ * one latest entry before any bytes are handed to vscode-jsonrpc. Once an
+ * entry starts, it runs to completion; LSP has no cancellation/acknowledgement
+ * for notifications, so dropping a started write could violate didOpen before
+ * didChange ordering or leave a partial message in the pipe.
+ */
+function enqueueDocumentNotify(state, normalizedPath, run) {
+    let queue = state.notifyChangeQueues.get(normalizedPath);
+    if (!queue) {
+        queue = { running: false };
+        state.notifyChangeQueues.set(normalizedPath, queue);
+    }
+    return new Promise((resolve, reject) => {
+        const previous = queue?.pending;
+        // Keep superseded callers attached to the replacement's completion. The
+        // notification is dropped, but callers such as the auxiliary backlog
+        // ledger must not observe completion before the newest content is sent.
+        const waiters = previous?.waiters ?? [];
+        waiters.push({ resolve, reject });
+        queue.pending = {
+            run,
+            waiters,
+            coalescedCount: (previous?.coalescedCount ?? 0) + (previous ? 1 : 0),
+        };
+        if (queue.running)
+            return;
+        queue.running = true;
+        // Let same-turn callers replace the unwritten entry before the runner
+        // invokes the transport. Different path queues still start independently.
+        void Promise.resolve().then(async () => {
+            try {
+                for (;;) {
+                    const next = queue.pending;
+                    if (!next)
+                        break;
+                    queue.pending = undefined;
+                    try {
+                        await next.run(next.coalescedCount);
+                        for (const waiter of next.waiters)
+                            waiter.resolve();
+                    }
+                    catch (error) {
+                        for (const waiter of next.waiters)
+                            waiter.reject(error);
+                    }
+                }
+            }
+            finally {
+                queue.running = false;
+                if (!queue.pending &&
+                    state.notifyChangeQueues.get(normalizedPath) === queue) {
+                    state.notifyChangeQueues.delete(normalizedPath);
+                }
+            }
+        });
+    });
+}
+/** Drop unwritten document notifications when a client is torn down. */
+function cancelDocumentNotifyQueues(state) {
+    for (const queue of state.notifyChangeQueues.values()) {
+        for (const waiter of queue.pending?.waiters ?? [])
+            waiter.resolve();
+        queue.pending = undefined;
+    }
+    state.notifyChangeQueues.clear();
+}
+export function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false) {
+    if (!isClientAlive(state))
+        return Promise.resolve();
+    const normalizedPath = normalizeMapKey(filePath);
+    return enqueueDocumentNotify(state, normalizedPath, (coalescedCount) => handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount));
+}
+async function handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount = 0) {
     if (!isClientAlive(state))
         return;
     const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
@@ -2566,7 +2661,7 @@ async function handleNotifyChangeOnce(state, filePath, content, normalizedPath)
         state.documentOpenedAt.set(normalizedPath, Date.now());
         state.diagnosticPublicationCounts.set(normalizedPath, 0);
         if (fallbackOpenSent)
-            recordSentContent(state, normalizedPath, 0, content);
+            recordSentContent(state, normalizedPath, 0, content, coalescedCount);
         state.openDocuments.add(normalizedPath);
         state.openDocumentUris?.set(normalizedPath, uri);
         return;
@@ -2581,7 +2676,7 @@ async function handleNotifyChangeOnce(state, filePath, content, normalizedPath)
         contentChanges: buildContentChanges(state, normalizedPath, content),
     });
     if (changeSent)
-        recordSentContent(state, normalizedPath, version, content);
+        recordSentContent(state, normalizedPath, version, content, coalescedCount);
 }
 /**
  * #2113: serialize the read/build/send/record transaction per document. The
@@ -2592,17 +2687,7 @@ export function handleNotifyChange(state, filePath, content) {
     if (!isClientAlive(state))
         return Promise.resolve();
     const normalizedPath = normalizeMapKey(filePath);
-    const previous = state.notifyChangeQueues.get(normalizedPath) ?? Promise.resolve();
-    const queued = previous
-        .catch(() => undefined)
-        .then(() => handleNotifyChangeOnce(state, filePath, content, normalizedPath));
-    const settled = queued.finally(() => {
-        if (state.notifyChangeQueues.get(normalizedPath) === settled) {
-            state.notifyChangeQueues.delete(normalizedPath);
-        }
-    });
-    state.notifyChangeQueues.set(normalizedPath, settled);
-    return settled;
+    return enqueueDocumentNotify(state, normalizedPath, (coalescedCount) => handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount));
 }
 /** Close a document through the same lifecycle path exposed by the client. */
 export async function closeDocument(state, filePath) {
@@ -2739,6 +2824,9 @@ async function clientShutdownOnce(state, options) {
     state.pendingOpens.clear();
     state.openDocuments.clear();
     state.openDocumentUris?.clear();
+    // #2357: superseded notifications that have not started writing are moot
+    // once this client is dead; resolve their callers and release the queue.
+    cancelDocumentNotifyQueues(state);
     // #1412 L1: mirror openDocuments' clear — a shut-down/evicted client's
     // probe memo is moot along with everything else document-scoped.
     state.projectIdentityProbedFiles?.clear();
@@ -3183,6 +3271,35 @@ async function clientPingLiveness(state, timeoutMs = LIVENESS_PING_TIMEOUT_MS) {
     }
     return isClientAlive(state);
 }
+// #2479: `activeMutationContext` is DERIVED state, not a stack. The frame that
+// takes `activeMutationDepth` 0 -> 1 owns the context for its whole lifetime
+// (`mutationContextOwner`); the slot merely exposes that owner while it is the
+// ONLY frame in flight. Deeper or overlapping frames therefore empty the slot
+// for as long as they are open — concurrent and nested commands deliberately
+// do not cross-correlate — and it refills by itself when they unwind, with no
+// frame having to remember anything.
+//
+// Recomputing beats saving and restoring because these frames do not nest:
+// `LSPClient.executeCommand` and `LSPService.executeCommand` fan out with no
+// mutex, parallel `lsp_navigation` calls with `apply: true` overlap, and #449
+// light mode shares one client across agents. With A (the owner), B and C
+// overlapping and the MIDDLE one settling first, a per-frame restore hands A's
+// context back while C's window is the open one — and `LspMutationContext`
+// carries a cwd plus a directly-threaded runtime/cacheManager, with
+// `readTurnState` / `appendProjectChange` cwd-scoped, so that routes a live
+// edit's bookkeeping into another project's change log (strictly worse than
+// the honest fallback the pre-#2479 code gave). An owner-liveness flag does
+// not fix it either: it answers "is an owner live", not "does the slot belong
+// to the window this edit is in" — and C's own unwind then puts back the
+// `undefined` it saved while the owner is still running, resurrecting #2479
+// (review round 3). Deriving answers the second question by construction, and
+// "no command in flight == no context" — the invariant the
+// `serverEditsAllowed` gate on `workspace/applyEdit` is paired with — falls
+// out of it with no depth-0 special case.
+function syncMutationContextSlot(state) {
+    state.activeMutationContext =
+        state.activeMutationDepth === 1 ? state.mutationContextOwner : undefined;
+}
 // Run an advertised server command via workspace/executeCommand, with the
 // generous EXECUTE_COMMAND_TIMEOUT_MS anti-deadlock backstop. Preserves the
 // hardening invariants: allowlist-by-advertisement (only commands the server
@@ -3201,10 +3318,20 @@ export async function runServerCommand(state, command, args, timeoutMs = EXECUTE
     }
     state.serverEditsAllowed += 1;
     state.activeMutationDepth = (state.activeMutationDepth ?? 0) + 1;
-    if (state.activeMutationDepth === 1)
-        state.activeMutationContext = mutationContext;
-    else
-        state.activeMutationContext = undefined;
+    // #2479: the frame that takes the depth to 1 owns the context; the slot is
+    // derived from that owner (see `syncMutationContextSlot` above). The
+    // pre-#2479 shape only ever CLEARED the slot, and only once the depth
+    // returned to 0, so a nested `executeCommand` unwinding from depth 2 back
+    // to 1 left the OUTER call without its own context for the rest of its
+    // window: every server-initiated `applyEdit` it still solicited read
+    // `undefined`, fell to the mutation bridge, and carried the generic
+    // `agent-tool:lsp-workspace-applyEdit` receipt instead of the outer
+    // operation's own (`lsp-rename` / `lsp-execute-command`).
+    const isMutationContextOwner = state.activeMutationDepth === 1;
+    if (isMutationContextOwner) {
+        state.mutationContextOwner = mutationContext;
+    }
+    syncMutationContextSlot(state);
     try {
         let result;
         try {
@@ -3231,8 +3358,15 @@ export async function runServerCommand(state, command, args, timeoutMs = EXECUTE
     finally {
         state.serverEditsAllowed -= 1;
         state.activeMutationDepth = Math.max(0, (state.activeMutationDepth ?? 0) - 1);
-        if (state.activeMutationDepth === 0)
-            state.activeMutationContext = undefined;
+        // The owner drops its context; every frame then resyncs. Both the
+        // hand-back to a still-live owner once the deeper frames unwind and
+        // the empty slot while more than one frame is open are consequences of
+        // the derivation, not separate rules each frame has to get right
+        // (#2479 review rounds 2/3).
+        if (isMutationContextOwner) {
+            state.mutationContextOwner = undefined;
+        }
+        syncMutationContextSlot(state);
     }
 }
 // #1412 H1/H2: read-only sibling of runServerCommand for telemetry/identity
@@ -3365,7 +3499,7 @@ async function resolveCodeActionBestEffort(state, action) {
 // --- Client Factory ---
 export async function createLSPClient(options) {
     installCrashGuard();
-    const { serverId, process: lspProcess, root, sessionCwd, initialization, initializeTimeoutMs = INITIALIZE_TIMEOUT_MS, launchVariant, } = options;
+    const { serverId, process: lspProcess, root, sessionCwd, initialization, initializeTimeoutMs = INITIALIZE_TIMEOUT_MS, launchVariant, onDiagnosticsPublished, } = options;
     // #449/#472: register this LSP child in the cross-process instance registry
     // as soon as we have a live pid — BEFORE `initialize` completes, not after.
     // Registering early means a child that dies/hangs during initialize (the
@@ -3538,7 +3672,7 @@ export async function createLSPClient(options) {
             return;
         void safeSendNotification(state.connection, "workspace/didChangeWatchedFiles", { changes });
     });
-    setupIncomingHandlers(state, initialization);
+    setupIncomingHandlers(state, initialization, onDiagnosticsPublished);
     connection.listen();
     setupConnectionLifecycle(state, recentStderr);
     let initResult;
@@ -3694,6 +3828,8 @@ export async function createLSPClient(options) {
         checkAlive: () => checkProcessAlive(),
         /** #1277: cheap request round-trip proving the server still responds. */
         pingLiveness: (timeoutMs) => clientPingLiveness(state, timeoutMs),
+        /** #2358: the OS pid of the live server process (see interface doc). */
+        getProcessPid: () => lspProcess.pid,
         notify: {
             async open(filePath, content, languageId, preserveDiagnostics, silent) {
                 return handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics, silent);
@@ -3842,6 +3978,9 @@ export async function createLSPClient(options) {
         isDocumentOpen(filePath) {
             return state.openDocuments.has(normalizeMapKey(filePath));
         },
+        openDocumentPaths() {
+            return [...state.openDocuments];
+        },
         isBusy() {
             return (activeRequestsByConnection.get(connection) ?? 0) > 0;
         },