@herbertgao/pi-extensions 2026.9.14 → 2026.9.16

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

@@ -74,6 +74,14 @@ export class JscpdClient {
     constructor(verbose = false) {
         this.log = verbose ? createSubsystemLogger("jscpd") : () => { };
     }
+    /**
+     * Wait for scans already started by this client to settle. Test owners use
+     * this as the lifecycle barrier before removing fixture roots; the scan
+     * promise includes the jscpd child and its report-directory cleanup.
+     */
+    async shutdown() {
+        await Promise.allSettled(this.inFlight.values());
+    }
     /**
      * Fast recursive source file presence check.
      * Avoids running jscpd when repo has no relevant source files.

package/node_modules/pi-lens/dist/clients/latency-logger.js

@@ -85,6 +85,12 @@ let recentPhases = [];
  * zero-duration session-end summary of records already logged individually,
  * not new work of its own.
  *
+ * #3310: `lsp_empty_first_publish_held` is the same shape as the #1459
+ * scanner-coverage rows — a decision record written from inside a live
+ * `lsp_touch_file` wait whose `durationMs` is ANOTHER write's age (how long
+ * after `didOpen` the server's pre-index empty publish arrived), not its own
+ * work. The touch it fires inside owns any real stall.
+ *
  * #2044: `test_runner_failed_target_state` is a zero-duration decision after a
  * bounded filesystem probe. The surrounding turn-end test-selection phase owns
  * any real work, so this row must not replace it in stall attribution.
@@ -104,6 +110,7 @@ const LAST_PHASE_EXCLUDED = new Set([
     "availability_decision",
     "finding_dead_path_drop",
     "finding_stale_line_demote",
+    "finding_path_stat_budget_exhausted",
     "lsp_scanner_coverage_gap",
     "lsp_notify_resync_deferred",
     "lsp_notify_write_late_landed",
@@ -112,6 +119,7 @@ const LAST_PHASE_EXCLUDED = new Set([
     "path_attribution_verified_rollup",
     "concurrent_session_bind_rollup",
     "auxiliary_readiness",
+    "lsp_empty_first_publish_held",
 ]);
 /**
  * The last non-`loop_block` phase logged, or undefined if none yet. Carries its

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

@@ -1,12 +1,13 @@
 import { resetIgnoredConfigWarnCache, warnIgnoredConfigOnce, } from "./config-warn.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
 import { errorClassName } from "./error-class.js";
 import * as path from "node:path";
 import { assignFlagConfigSection, flagConfigSectionKeys, flagValueFromConfig, getLensFlagSpec, GLOBAL_NON_FLAG_CONFIG_SECTIONS, LENS_FLAGS, readFlagConfigValue, } from "./lens-flag-registry.js";
-import { CANONICAL_GLOBAL_CONFIG_FILE, getPiLensGlobalConfigPath, GLOBAL_CONFIG_LOCATIONS, LEGACY_ROOT_LSP_KEYS, } from "./config-locations.js";
+import { CANONICAL_GLOBAL_CONFIG_FILE, canonicalPathIdentity, getPiLensGlobalConfigPath, getProductionGlobalConfigResolution, GLOBAL_CONFIG_LOCATIONS, LEGACY_ROOT_LSP_KEYS, } from "./config-locations.js";
 // Re-exported so this module's own, pre-existing import sites (`./lens-config.js`
 // / `../lens-config.js`) keep working. The function itself now lives in
 // `config-locations.ts` (#2426 review round 3, S1) — see the doc comment there.
-export { getPiLensGlobalConfigPath } from "./config-locations.js";
+export { getPiLensGlobalConfigPath, getProductionGlobalConfigResolution, isResolvedGlobalConfigPath, resolveGlobalConfigLocation, resetGlobalConfigLocationCache, } from "./config-locations.js";
 import { ignoredRecordCollector, readConfigDocument, reportConfigReadFailure, reportPiLensConfigRecords, resolveOnePiLensConfigDocument, } from "./config-resolve.js";
 import { findNestedProjectMutationValue, } from "./project-lens-config.js";
 import { readToolConfig } from "./tool-config.js";
@@ -46,7 +47,64 @@ function asConfigObject(value) {
         ? value
         : undefined;
 }
-export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath()) {
+/**
+ * Report a probe-error RETENTION decision once (global-config-location PR,
+ * refs #2457; review H2 remedy B).
+ *
+ * Fired by `loadPiLensGlobalConfig` when it derived the path itself and the
+ * resolution retained a location whose existence probe THREW. The record
+ * names the retained path (subject) and the failed probe's error class;
+ * once per session via `recordDegradationOnce`. A successful
+ * non-canonical selection fires nothing (opt-in by file creation, visible
+ * via `pilens_effective_config`).
+ */
+function reportGlobalConfigProbeRetention() {
+    const resolution = getProductionGlobalConfigResolution();
+    if (resolution.source !== "legacy-default-unprobed" &&
+        resolution.source !== "pi-coding-agent-dir-unprobed") {
+        return;
+    }
+    recordDegradationOnce({
+        kind: "config-location-probe-failed",
+        subject: resolution.path,
+        reason: `existence probe for ${resolution.existsProbeFailed?.path} failed (${resolution.existsProbeFailed?.errorClassName}); the location is retained as the config source and its read failures report through PILENS_CFG_0001`,
+        metadata: { subsystem: "lens-config", configPath: resolution.path },
+    });
+}
+/** Report a lower-precedence global config that exists beside the winner. */
+function reportGlobalConfigShadowing() {
+    const resolution = getProductionGlobalConfigResolution();
+    if (resolution.shadowedPath === undefined)
+        return;
+    const winningPath = canonicalPathIdentity(resolution.path);
+    const shadowedPath = canonicalPathIdentity(resolution.shadowedPath);
+    recordDegradationOnce({
+        kind: "config-location-shadowed",
+        subject: winningPath,
+        reason: `shadowed global config ${shadowedPath}; winning path is the record subject`,
+        metadata: {
+            subsystem: "lens-config",
+            configPath: winningPath,
+            shadowedPath,
+        },
+        code: "PILENS_CFG_0010",
+    });
+}
+export function loadPiLensGlobalConfig(configPath) {
+    // An unresolvable existence probe on the derived path is the one decision
+    // that must carry its own bounded record (#3251 review H2 remedy B): the
+    // resolution RETAINED the location it could not evaluate, the read below
+    // reports its own `config-ignored` row when it fails, and this record
+    // names the retention decision itself - the failed probe's path and error
+    // class - so "different settings silently applying" is impossible.
+    // Explicit-path callers stay silent (#2427 quiet contract); the default
+    // parameter is evaluated FIRST so the body can tell derived from explicit.
+    const derivedPath = configPath === undefined;
+    if (derivedPath) {
+        reportGlobalConfigProbeRetention();
+        reportGlobalConfigShadowing();
+    }
+    const resolvedPath = configPath ?? getPiLensGlobalConfigPath();
     const location = globalCanonicalLocation();
     // #2445: this used to be `JSON.parse(fs.readFileSync(...))` inside a bare
     // `catch { return undefined; }`, so a malformed `~/.pi-lens/config.json`
@@ -58,12 +116,12 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
     // `reportConfigReadFailure` derives the subsystem from the DOCUMENT so the
     // LSP loader's report of this file lands under `lens-config` as well and the
     // warn-once latch collapses the two into one honest notice.
-    const outcome = readConfigDocument(configPath);
+    const outcome = readConfigDocument(resolvedPath);
     if (outcome.status === "missing")
         return undefined;
     if (outcome.status === "error") {
         reportConfigReadFailure({
-            file: configPath,
+            file: resolvedPath,
             location,
             tier: "global",
             error: outcome.error,
@@ -92,7 +150,7 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
     // The flush is in a `finally` so a throw in the projection still delivers
     // what was composed before it, on top of the whole-config record the catch
     // adds.
-    const { note, records: notedRecords } = ignoredRecordCollector(configPath, "global");
+    const { note, records: notedRecords } = ignoredRecordCollector(resolvedPath, "global");
     try {
         const parsed = outcome.value;
         if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -110,7 +168,7 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
         // function still decides what a bad value is called.
         const document = {
             tier: "global",
-            file: configPath,
+            file: resolvedPath,
             location,
             value: parsed,
         };
@@ -269,7 +327,7 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
         // calling the same leaf `config-warn.ts` itself delegates to keeps every
         // caller of this guarantee, `config-core/` included, on ONE
         // implementation rather than two that happen to agree today.
-        warnInvalidGlobalConfigOnce(configPath, `global config could not be interpreted (${errorClassName(error)}); configuration ignored`, "PILENS_CFG_0008");
+        warnInvalidGlobalConfigOnce(resolvedPath, `global config could not be interpreted (${errorClassName(error)}); configuration ignored`, "PILENS_CFG_0008");
         return undefined;
     }
     finally {

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

@@ -32,7 +32,8 @@ import { hashDiagnosticContent, } from "./diagnostic-binding.js";
 import { applyWorkspaceEdit, normalizeWorkspaceEditToUtf16 } from "./edits.js";
 import { normalizeMapKey, uriToPath } from "./path-utils.js";
 import { ADVERTISED_POSITION_ENCODINGS, convertCharacterOffset, lineTextAt, negotiatePositionEncoding, } from "./position-encoding.js";
-import { negotiateSyncKind, TEXT_DOCUMENT_SYNC_KIND_FULL, TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL, } from "./sync-kind.js";
+import { negotiateSaveOptions, negotiateSyncKind, TEXT_DOCUMENT_SYNC_KIND_FULL, TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL, } from "./sync-kind.js";
+import { exceedsLspSyncLimits } from "./content-limits.js";
 import { probeTsserverProjectIdentity } from "./tsserver-sync.js";
 import { getStrategy } from "./wait-policy/index.js";
 import { WatchedFilesQueue } from "./watch-queue.js";
@@ -1162,13 +1163,13 @@ export function applyDynamicCapabilities(state) {
 }
 export function resolveConfigurationSection(initialization, section) {
     if (!initialization)
-        return section ? null : {};
+        return {};
     if (!section)
         return initialization;
     let cur = initialization;
     for (const part of section.split(".")) {
         if (typeof cur !== "object" || cur === null || !Object.hasOwn(cur, part)) {
-            return null;
+            return {};
         }
         cur = cur[part];
     }
@@ -1326,6 +1327,60 @@ export function setupIncomingHandlers(state, initialization, onDiagnosticsPublis
             const currentVersion = state.documentVersions.get(normalizedPath);
             return currentVersion !== undefined && docVersion < currentVersion;
         };
+        // #3310: HOLD the empty first publish of an asynchronously-indexing
+        // server. Measured (docs/lsp-capability-matrix.md's `first-publish`
+        // column): intelephense answers `didOpen` with `[]` while its
+        // whole-workspace index builds and publishes the real set once
+        // indexing ends, so letting that first publish through cached an empty
+        // set, bumped the publication stamp and emitted — which resolved the
+        // push wait AND satisfied the "answered" evidence check in
+        // `clients/lsp/index.ts`, rendering a file with an error as "confirmed
+        // clean". A timeout is not a false clean; an empty pre-index publish
+        // must not become one either.
+        //
+        // Held means: not cached, no version bump, no emit — so it can neither
+        // resolve a wait nor count as evidence. Nothing is scheduled and
+        // nothing is awaited: the server's OWN next publish releases the hold
+        // (it is no longer a first publish), and the existing per-server budget
+        // stays the only bound, so there is no new timer, listener or
+        // cancellation path. A genuinely clean file still gets an affirmative
+        // clean, because the measured server re-publishes `[]` at the end of
+        // indexing.
+        //
+        // Three conditions, each load-bearing:
+        //  - the MEASURED class (never every push server): a Tier 2/2* server
+        //    that publishes `[]` once for a clean file keeps resolving the wait
+        //    on it, with no added latency (#3310 AC2);
+        //  - one-shot per client session: the cold index builds once, so a warm
+        //    touch — or a class server that never re-publishes — pays nothing;
+        //  - FIRST publication for this document: no cached push AND no pending
+        //    debounce timer. An empty publish that CLEARS an earlier non-empty
+        //    one (a fix landing) is never held, in either arrival order.
+        if (strategy.emptyFirstPublish === "indexing" &&
+            !state.emptyFirstPublishHoldSpent &&
+            newDiags.length === 0 &&
+            !state.pushDiagnostics.has(normalizedPath) &&
+            !state.pendingDiagnostics.has(normalizedPath)) {
+            state.emptyFirstPublishHoldSpent = true;
+            // Bounded by construction: one record per client session, because
+            // the hold itself is one-shot.
+            logLatency({
+                type: "phase",
+                phase: "lsp_empty_first_publish_held",
+                filePath: normalizedPath,
+                durationMs: Math.max(0, publishReceivedAt -
+                    (state.documentOpenedAt.get(normalizedPath) ?? publishReceivedAt)),
+                metadata: {
+                    serverId: state.serverId,
+                    emptyFirstPublish: strategy.emptyFirstPublish,
+                    // `pubVersion`, the `[lsp-pub]` trace's own field name for the
+                    // publish's LSP document version — not a lifecycle identity, and
+                    // not the retired glossary spelling (AGENTS.md "generation").
+                    pubVersion: docVersion ?? "push-unversioned",
+                },
+            });
+            return;
+        }
         // Seed on first push for servers whose first push is known complete.
         // Bypasses the debounce timer entirely — resolves waiting promises immediately.
         if (strategy.seedFirstPush &&
@@ -1477,7 +1532,9 @@ export function setupIncomingHandlers(state, initialization, onDiagnosticsPublis
     // dot-path into the server's config, e.g. "scan.jobs") — not a fixed
     // single-element array duplicating the whole blob for every item. An item
     // with no `section` gets the whole blob (that's what "no section" means
-    // per spec); an unresolvable section gets `null`, never the whole blob.
+    // per spec); an unresolvable section gets `{}` (never `null`: strict consumers such as
+    // vscode-css-language-server and @prisma/language-server throw or exit on
+    // null), never the whole blob.
     state.connection.onRequest("workspace/configuration", async (params) => {
         const items = params?.items ?? [];
         return items.map((item) => resolveConfigurationSection(initialization, item?.section));
@@ -2455,7 +2512,64 @@ export function handleNotifyExternalChange(state, filePath, type) {
     const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
     state.watchQueue.enqueue(uri, type);
 }
-async function handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0) {
+/**
+ * #3405: tell the server the document it just received is the file's saved
+ * on-disk state.
+ *
+ * pi-lens has no unsaved-buffer concept — every notification it sends carries
+ * bytes read from disk — so a save-triggered server is the one class of server
+ * this client could never reach: `CLIENT_CAPABILITIES` has advertised
+ * `synchronization.didSave` since #278 and no caller emitted one, so Expert
+ * (whose ONLY whole-project recompile trigger is didSave —
+ * `expert-lsp/expert@6bbad8c` `apps/expert/lib/expert/state.ex:243-257`)
+ * published nothing for an edit made through pi-lens.
+ *
+ * Sent ONLY when the caller declared this touch a save (`saved`) AND the server
+ * declared `textDocumentSync.save`; `includeText` decides whether the text
+ * rides along. Both gates fail closed: an undeclared notification is the #278
+ * class of hazard, and a save claimed for content whose didOpen/didChange never
+ * left the process would tell the server to diagnose bytes it does not have —
+ * so every call site below sends this only after its own content notification
+ * returned `true` from `safeSendNotification`, and never for a document this
+ * client has not opened.
+ */
+async function sendDidSave(state, uri, content) {
+    const save = state.saveOptions;
+    if (!save)
+        return;
+    if (!isClientAlive(state))
+        return;
+    // #3405 r2 (M3406-1): `text` is a SECOND full copy of bytes the server was
+    // just handed, so it is the one payload here that can be file-sized. The
+    // explicit `lsp_diagnostics` writer reads whole files with no bound of its
+    // own, so without this the same 32MB string would be framed twice. Bound it
+    // at the shared seam both writers pass through rather than at either caller.
+    //
+    // Omitting `text` is what the contract tolerates, and it is not a lost save:
+    // `DidSaveTextDocumentParams.text` is OPTIONAL ("Optional the content when
+    // saved") in the spec, FsAutoComplete — the one `includeText: true` server in
+    // the registry — types it `string option` and, given `None`, keeps the source
+    // it already holds and still runs its re-check
+    // (ionide/FsAutoComplete@85886b1, AdaptiveServerState.fs lines 2649-2673),
+    // and pi-lens only ever sends this after a landed didOpen/didChange for the
+    // same document, so the server has these bytes either way. Skipping the save
+    // outright would instead drop the diagnose trigger this PR exists to restore.
+    const limit = save.includeText
+        ? exceedsLspSyncLimits(content)
+        : { tooLarge: false, reason: "" };
+    if (limit.tooLarge) {
+        recordDegradationOnce({
+            kind: "lsp-did-save-text-omitted",
+            subject: state.serverId,
+            reason: limit.reason,
+        });
+    }
+    await safeSendNotification(state.connection, "textDocument/didSave", {
+        textDocument: { uri },
+        ...(save.includeText && !limit.tooLarge ? { text: content } : {}),
+    });
+}
+async function handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0, saved = false) {
     if (!isClientAlive(state))
         return;
     const normalizedPath = normalizeMapKey(filePath);
@@ -2506,6 +2620,8 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
                 recordSentContent(state, normalizedPath, version, content, coalescedCount);
             state.openDocuments.add(normalizedPath);
             state.openDocumentUris?.set(normalizedPath, uri);
+            if (saved && reopenSent)
+                await sendDidSave(state, uri, content);
             return;
         }
         const changeSent = await safeSendNotification(state.connection, "textDocument/didChange", {
@@ -2514,6 +2630,8 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
         });
         if (changeSent)
             recordSentContent(state, normalizedPath, version, content, coalescedCount);
+        if (saved && changeSent)
+            await sendDidSave(state, uri, content);
         return;
     }
     state.pendingOpens.add(normalizedPath);
@@ -2553,6 +2671,8 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
     state.openDocuments.add(normalizedPath);
     state.closedDocuments?.delete(normalizedPath);
     state.openDocumentUris?.set(normalizedPath, uri);
+    if (saved && openSent)
+        await sendDidSave(state, uri, content);
     // Telemetry is deliberately detached after didOpen succeeds.
     // #1412 H1: routed through runReadOnlyServerCommand, NOT runServerCommand —
     // the probe must never open the serverEditsAllowed/activeMutationContext
@@ -2580,7 +2700,7 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
  * 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) {
+function enqueueDocumentNotify(state, normalizedPath, run, saved = false) {
     let queue = state.notifyChangeQueues.get(normalizedPath);
     if (!queue) {
         queue = { running: false };
@@ -2597,6 +2717,7 @@ function enqueueDocumentNotify(state, normalizedPath, run) {
             run,
             waiters,
             coalescedCount: (previous?.coalescedCount ?? 0) + (previous ? 1 : 0),
+            saved: saved || previous?.saved === true,
         };
         if (queue.running)
             return;
@@ -2611,7 +2732,7 @@ function enqueueDocumentNotify(state, normalizedPath, run) {
                         break;
                     queue.pending = undefined;
                     try {
-                        await next.run(next.coalescedCount);
+                        await next.run(next.coalescedCount, next.saved);
                         for (const waiter of next.waiters)
                             waiter.resolve();
                     }
@@ -2640,11 +2761,11 @@ function cancelDocumentNotifyQueues(state) {
     }
     state.notifyChangeQueues.clear();
 }
-export function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false) {
+export function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, saved = false) {
     if (!isClientAlive(state))
         return Promise.resolve();
     const normalizedPath = normalizeMapKey(filePath);
-    return enqueueDocumentNotify(state, normalizedPath, (coalescedCount) => handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount));
+    return enqueueDocumentNotify(state, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount, queuedSaved), saved);
 }
 async function handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount = 0) {
     if (!isClientAlive(state))
@@ -2691,6 +2812,10 @@ export function handleNotifyChange(state, filePath, content) {
     if (!isClientAlive(state))
         return Promise.resolve();
     const normalizedPath = normalizeMapKey(filePath);
+    // #3405: no `saved` argument — `LSPService.updateFile` is this path's only
+    // entry point and no caller declares a save through it, so a change never
+    // originates one. A save intent inherited from a superseded open entry is
+    // dropped here by construction rather than sent after a bare didChange.
     return enqueueDocumentNotify(state, normalizedPath, (coalescedCount) => handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount));
 }
 /** Close a document through the same lifecycle path exposed by the client. */
@@ -3643,6 +3768,8 @@ export async function createLSPClient(options) {
         pullRequestSequences: new Map(),
         workspacePullResultCache: new Map(),
         openDocuments: new Set(),
+        // #3310: one-shot, per client session.
+        emptyFirstPublishHoldSpent: false,
         closedDocuments: new Set(),
         openDocumentUris: new Map(),
         pendingOpens: new Set(),
@@ -3798,6 +3925,7 @@ export async function createLSPClient(options) {
     }
     state.positionEncoding = negotiatePositionEncoding(initResult?.capabilities);
     state.syncKind = negotiateSyncKind(initResult?.capabilities);
+    state.saveOptions = negotiateSaveOptions(initResult?.capabilities);
     state.rawCapabilityKeys = Object.keys(initResult?.capabilities ??
         {}).sort((a, b) => a.localeCompare(b));
     for (const cmd of detectExecuteCommands(initResult)) {
@@ -3835,8 +3963,8 @@ export async function createLSPClient(options) {
         /** #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);
+            async open(filePath, content, languageId, preserveDiagnostics, silent, saved) {
+                return handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics, silent, saved);
             },
             async change(filePath, content) {
                 return handleNotifyChange(state, filePath, content);

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

@@ -261,13 +261,15 @@ export async function loadLSPConfig(cwd, homeDir = os.homedir(), options = {}) {
     const resolution = resolvePiLensConfig({
         cwd,
         globalDir: getGlobalPiLensDir(),
-        // `homeDir` is threaded, not dropped: it is the `$HOME` this call resolves
-        // against, and the canonical global config is `$HOME/.pi-lens/config.json`
-        // whenever `PI_LENS_CONFIG_PATH` does not override it. Production behavior
-        // is unchanged (the default IS `os.homedir()`); what it buys is that the
-        // seam means the same `$HOME` on both sides of the resolution, so a test
-        // can exercise a relocated `PI_LENS_HOME` without reaching the real one.
-        globalConfigPath: getPiLensGlobalConfigPath(homeDir),
+        // The global tier reads the PRODUCTION resolution (global-config-location
+        // PR, refs #2457): which file supplies it is an env fact (PI_LENS_CONFIG_PATH,
+        // then a legacy default, then PI_CODING_AGENT_DIR, then the
+        // PI_LENS_HOME-relocated canonical default), not a property of the
+        // `$HOME` this call's project walk is ceiling-bounded by. `homeDir`
+        // stays threaded below for the walk and `globalDir`; a test redirecting
+        // the global tier does it through the env, the same way production is
+        // controlled.
+        globalConfigPath: getPiLensGlobalConfigPath(),
         homeDir,
         // The subsystem comes from the failing DOCUMENT, not from this loader
         // (#2445). This resolution opens `~/.pi-lens/config.json` and

package/node_modules/pi-lens/dist/clients/lsp/content-limits.js

@@ -0,0 +1,41 @@
+/**
+ * The one byte/line bound on document content pi-lens hands a language server.
+ *
+ * #3405 r2 (M3406-1): this predicate used to exist twice — as a private
+ * `exceedsLspSyncLimits` in `clients/pipeline.ts` and again inline in
+ * `clients/dispatch/runners/lsp.ts` — so a THIRD writer could be added that
+ * simply had neither. That is what happened: `tools/lsp-diagnostics.ts` reads a
+ * whole file with `fs.readFileSync` and touches with it, and once the touch
+ * could also carry `textDocument/didSave.text` (`includeText`), the same
+ * unbounded string was serialized into a second JSON-RPC frame. Both callers now
+ * ask this module, and so does the didSave payload seam, so the bound is one
+ * constant pair in one place rather than a convention each new writer must
+ * remember.
+ *
+ * The two established callers act on it by skipping their whole LSP step — a
+ * file this large is not synced at all. That behaviour is deliberately NOT
+ * folded in here: what a caller does at the bound is the caller's policy, and
+ * `sendDidSave`'s is different (it drops the redundant `text` and still sends
+ * the save, because the server already received these bytes in the didOpen or
+ * didChange this save follows).
+ */
+import { RUNTIME_CONFIG } from "../runtime-config.js";
+const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
+const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
+export function exceedsLspSyncLimits(content) {
+    const sizeBytes = Buffer.byteLength(content, "utf-8");
+    if (sizeBytes > LSP_MAX_FILE_BYTES) {
+        return {
+            tooLarge: true,
+            reason: `${sizeBytes} bytes > ${LSP_MAX_FILE_BYTES} limit`,
+        };
+    }
+    const lineCount = content.split("\n").length;
+    if (lineCount > LSP_MAX_FILE_LINES) {
+        return {
+            tooLarge: true,
+            reason: `${lineCount} lines > ${LSP_MAX_FILE_LINES} limit`,
+        };
+    }
+    return { tooLarge: false, reason: "" };
+}

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

@@ -3792,7 +3792,7 @@ export class LSPService {
                         // (or any synchronous throw) still reads as a rejected write rather
                         // than rejecting the whole per-file `Promise.all`.
                         const writePromise = entry.client.notify
-                            .open(filePath, content, languageId, undefined, silent)
+                            .open(filePath, content, languageId, undefined, silent, options.saved === true)
                             .then(() => true);
                         // #1714: the document is now in this auxiliary's input queue,
                         // whether or not the write settles inside our budget. Counted here

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

@@ -68,9 +68,30 @@ function splitPathEntries(value, delimiter) {
         .map((entry) => entry.trim())
         .filter((entry) => entry.length > 0);
 }
+/**
+ * Dedupe key for one PATH entry, under `platform`'s rules.
+ *
+ * #1193 P3: the body used the HOST-DEFAULT `path.normalize` inside a branch
+ * already committed to `platform` (AGENTS.md defect shape 2), so on the ubuntu
+ * lane the win32 arm lowercased without folding separators or dot segments and
+ * `C:\Tools` / `C:/Tools` / `C:\x\..\Tools` were three keys for one directory.
+ * Each arm now parses with its own `path` flavor. That is the whole fix: a
+ * `toPosix` call on the win32 arm would be INERT — `win32.normalize` already
+ * answers backslashes for either input separator (measured: adding it left
+ * every case green) — and the POSIX arm must NOT fold separators at all,
+ * because a backslash is a legal POSIX filename character and `/opt/a\b` and
+ * `/opt/a/b` are two directories there.
+ *
+ * Ephemeral by construction: the key exists only inside one
+ * `combinePathValuesForPlatform` call's `seen` set — the ORIGINAL entry string
+ * is what survives into the joined PATH — so it never reaches a persisted or
+ * cross-process record and `normalizeEphemeralMapKey`'s `process.platform` read
+ * would defeat the explicit-`platform` seam these arms exist for.
+ */
 function normalizePathEntry(entry, platform) {
-    const normalized = path.normalize(entry);
-    return platform === "win32" ? normalized.toLowerCase() : normalized;
+    if (platform !== "win32")
+        return path.posix.normalize(entry);
+    return path.win32.normalize(entry).toLowerCase();
 }
 export function combinePathValuesForPlatform(values, platform = process.platform) {
     const unique = [];