@herbertgao/pi-extensions 2026.9.15 → 2026.9.17

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

@@ -16,7 +16,7 @@ export { detectPythonVenv };
 import { STAGE_TMP_PATTERN } from "../atomic-write-staging.js";
 import { DOTNET_CSHARP_ROOT_MARKERS, DOTNET_FSHARP_ROOT_MARKERS, KIND_EXTENSIONS, } from "../file-kinds.js";
 import { extensionsForLanguage } from "../language-registry.js";
-import { CARGO_WORKSPACE_MEMBER_DIALECT, direntsHaveMarkerGlobMatch, isAtOrAboveHomeDir, isFullyQualified, isWindowsPath, matchesWorkspaceMemberPattern, pathsEqual, } from "../path-utils.js";
+import { CARGO_WORKSPACE_MEMBER_DIALECT, direntsHaveMarkerGlobMatch, isAtOrAboveHomeDir, isFullyQualified, isWindowsPath, matchesWorkspaceMemberPattern, normalizeEphemeralMapKey, pathsEqual, toPosix, } from "../path-utils.js";
 import { ensureTool, findManagedToolBinary, getToolEnvironment, getToolPath, } from "../installer/index.js";
 import * as installer from "../installer/index.js";
 import { classifyProbeFailure, describeInstallAttempt, logAvailabilityDecision, } from "../dispatch/runners/utils/availability-policy.js";
@@ -28,6 +28,10 @@ import { findLocalSgconfig, resolveBaselineSgconfig } from "../sgconfig.js";
 import { findLocalTyposConfig } from "../typos-config.js";
 import { resolvePackagePath } from "../package-root.js";
 import { resolveToolCwd } from "../tool-cwd.js";
+import { dirMtimeRecordsAsync, dirMtimesStillFreshAsync, unknownDirMtimeRecords, } from "../workspace-topology.js";
+import { bounded } from "../deadline-utils.js";
+import { FRESHNESS_CADENCE_MS } from "../freshness-cadence.js";
+import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
 import { recordDegradationOnce } from "../degradation-ledger.js";
 import { hasCargoWorkspaceTable, readCargoWorkspaceExclude, readCargoWorkspaceMembers, readTextFileOrUndefined, } from "../cargo-manifest.js";
 import { resolveAstGrepNativeExe } from "./wait-policy/index.js";
@@ -871,30 +875,33 @@ function nodeBinLocalCandidates(root, baseName) {
 function nodeBinCandidates(root, baseName) {
     return [...nodeBinLocalCandidates(root, baseName), baseName];
 }
-function normalizeSlashKey(value) {
-    const normalized = path.resolve(value).replace(/\\/g, "/");
-    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
-}
 function piAgentExtensionsRootKey(file) {
-    const dirKey = normalizeSlashKey(path.dirname(path.resolve(file)));
+    // #1193 P3: `normalizeEphemeralMapKey` IS this module's former
+    // `normalizeSlashKey` — slash-fold, then lowercase only on win32 — and these
+    // directory keys are exactly what it is scoped for: process-local, same-run,
+    // derived from this process's own `path.resolve`, never persisted and never
+    // compared against an externally supplied spelling.
+    const dirKey = normalizeEphemeralMapKey(path.dirname(path.resolve(file)));
     const marker = "/.pi/agent/extensions";
     const index = dirKey.indexOf(marker);
     if (index === -1)
         return undefined;
     return dirKey.slice(0, index + marker.length);
 }
-function normalizeRootKey(root) {
-    return process.platform === "win32"
-        ? path.resolve(root).toLowerCase()
-        : path.resolve(root);
-}
 function IgnoreHomeRoot(primary) {
-    const homeKey = normalizeRootKey(os.homedir());
+    // #1193 P3: the former `normalizeRootKey` folded case on win32 but left the
+    // separator alone; both sides of the comparison below go through the same
+    // derivation, so adding the seam's slash fold cannot change the verdict for
+    // any spelling the old copy already agreed on, and it makes a mixed-separator
+    // root agree with the home directory it names.
+    const homeKey = normalizeEphemeralMapKey(path.resolve(os.homedir()));
     return withRootMarkers(async (file) => {
         const root = await primary(file);
         if (!root)
             return undefined;
-        return normalizeRootKey(root) === homeKey ? undefined : root;
+        return normalizeEphemeralMapKey(path.resolve(root)) === homeKey
+            ? undefined
+            : root;
     }, primary.rootMarkers ?? []);
 }
 function rubyBinCandidates(baseName) {
@@ -991,6 +998,22 @@ function isPermissionFsError(err) {
     const code = err?.code;
     return code === "EACCES" || code === "EPERM";
 }
+/**
+ * The directory `markerExists(dir, pattern)` reads to answer for `pattern`:
+ * `dir` itself for a plain basename, and the named subdirectory for a pattern
+ * that carries a path segment (`"prisma/schema.prisma"`). `NearestRoot`'s
+ * freshness records are keyed on these directories, so the derivation lives
+ * HERE, next to the probe it describes — a second copy could drift and silently
+ * stop covering a pattern shape (#3412).
+ */
+function markerProbeDir(dir, pattern) {
+    const normalized = toPosix(pattern);
+    const slash = normalized.lastIndexOf("/");
+    const parentPattern = slash >= 0 ? normalized.slice(0, slash) : "";
+    return parentPattern
+        ? path.join(dir, ...parentPattern.split("/").filter(Boolean))
+        : dir;
+}
 async function markerExists(dir, pattern) {
     if (!pattern.includes("*")) {
         try {
@@ -1006,13 +1029,10 @@ async function markerExists(dir, pattern) {
     }
     const normalized = pattern.replace(/\\/g, "/");
     const slash = normalized.lastIndexOf("/");
-    const parentPattern = slash >= 0 ? normalized.slice(0, slash) : "";
     const basenamePattern = slash >= 0 ? normalized.slice(slash + 1) : normalized;
     if (!basenamePattern)
         return false;
-    const targetDir = parentPattern
-        ? path.join(dir, ...parentPattern.split("/").filter(Boolean))
-        : dir;
+    const targetDir = markerProbeDir(dir, normalized);
     try {
         const entries = await readdir(targetDir, { withFileTypes: true });
         // Match files/symlinks only — a directory named like the marker (e.g. a
@@ -1028,8 +1048,22 @@ async function markerExists(dir, pattern) {
         return false;
     }
 }
-// --- Root Detection Helpers ---
-// --- Interactive Install Helper ---
+/**
+ * One bound for every directory-mtime read this detector awaits. `signal` is
+ * `undefined` on purpose: `RootFunction` takes a file path and nothing else, so
+ * no hook signal reaches this seam until #2523 AC4 threads one — the wall clock
+ * is the live half, and the registry entry says so. The budget is the edit
+ * `tool_result` one because that is the hook the per-file touch path runs under
+ * and the only hook the contract lets block the host; a tighter number would
+ * abandon a revalidation that is strictly CHEAPER than the walk it falls back
+ * to, making the hook slower rather than safer.
+ */
+const rootMtimeBound = (label) => ({
+    ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+    signal: undefined,
+    hook: "tool_result_edit",
+    label,
+});
 /**
  * Walk up the directory tree looking for project root markers.
  *
@@ -1055,21 +1089,55 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
     // present transition must work without a process restart. The uncached
     // re-walk cost for configless repos is a known trade-off; bounding the
     // walk with stopDir for in-cwd files is the tracked optimization (#1412).
+    //
+    // A HIT is revalidated instead of trusted for the session: it carries the
+    // mtime of every directory the walk probed, and is served only while all of
+    // them are unchanged. Without that, a nearer marker scaffolded below an
+    // already-resolved root (`swift package init` in a subdirectory) — and a
+    // marker REMOVED at the resolved root — stayed invisible for the whole
+    // session, the other half of the very transition the paragraph above
+    // handles (#3412; same shape as #2922 at the dispatch marker seam).
     const inFlight = new Map();
+    // The patterns whose probe reads a subdirectory of the walked directory
+    // instead of the walked directory itself: a pattern carrying a path segment
+    // (`prisma/schema.prisma`) is answered from a subdirectory, so creating that
+    // marker bumps the SUBDIRECTORY's mtime and the walked directory's own only
+    // when the subdirectory had to be created too. Derived once from this
+    // detector's pattern table, so a new pattern shape is covered on arrival
+    // without a second list to maintain.
+    const subdirPatterns = [];
+    for (const pattern of [...includePatterns, ...(excludePatterns ?? [])]) {
+        if (markerProbeDir("", pattern))
+            subdirPatterns.push(pattern);
+    }
     return withRootMarkers(async (file) => {
         // Cache key is the resolved directory — all files in the same dir share a root.
         const startDir = path.resolve(path.dirname(file));
         const dirKey = normalizeMapKey(startDir);
-        // Fast path: already resolved for this directory.
+        // Fast path: already resolved for this directory, nothing the walk looked at
+        // has changed since, and the entry is younger than the shared re-check
+        // cadence. One stat per probed directory replaces the whole walk (markers x
+        // directories, plus the hit directory's `isExcludedLspRoot` git-boundary
+        // walk), so the memo still pays for itself; the cadence is what bounds the
+        // axes a directory mtime cannot see — a same-tick create, and a `.gitignore`
+        // above the hit changing the exclusion verdict — to one window instead of
+        // the session (#3412 review round 1). A fired bound resolves `undefined`,
+        // which is NOT freshness: it falls through to the walk.
         const cached = cache.get(dirKey);
-        if (cached !== undefined)
-            return cached;
+        if (cached !== undefined &&
+            Date.now() - cached.walkedAt < FRESHNESS_CADENCE_MS &&
+            (await bounded(dirMtimesStillFreshAsync(cached.probedDirs), rootMtimeBound("lsp-root-memo-freshness"))) === true)
+            return cached.root;
         // In-flight deduplication: if N parallel pipelines edit files in the same
         // directory simultaneously, only one stat-walk runs; the rest await the same
         // promise. This is the main fix for parallel-turn LSP timeout spikes.
         const flying = inFlight.get(dirKey);
         if (flying)
             return flying;
+        const probedDirs = [];
+        // Stamped before the walk so the window also covers the walk's own duration
+        // — the conservative direction, by the walk's runtime (~0.2 ms measured).
+        const walkedAt = Date.now();
         const promise = (async () => {
             let currentDir = startDir;
             const fsRoot = path.parse(currentDir).root;
@@ -1080,6 +1148,19 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
                     currentDir !== stop) {
                     break;
                 }
+                // Record every directory this step is about to read, BEFORE reading
+                // it. Ordering is the invariant: a marker created between the stat
+                // and the probe leaves the record STALE (the next call re-walks and
+                // finds it), whereas recording afterwards would store the mtime that
+                // already includes the creation and hide it for the session. Only
+                // directories up to the hit are recorded — a marker created above a
+                // hit cannot change which root is nearest.
+                const stepDirs = [
+                    currentDir,
+                    ...subdirPatterns.map((pattern) => markerProbeDir(currentDir, pattern)),
+                ];
+                const stepRecords = await bounded(dirMtimeRecordsAsync(stepDirs), rootMtimeBound("lsp-root-walk-dir-mtimes"));
+                probedDirs.push(...(stepRecords ?? unknownDirMtimeRecords(stepDirs)));
                 // Check exclude patterns — skip this dir (but keep walking up)
                 if (excludePatterns) {
                     let excluded = false;
@@ -1114,7 +1195,7 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
         try {
             const result = await promise;
             if (result !== undefined)
-                cache.set(dirKey, result);
+                cache.set(dirKey, { root: result, probedDirs, walkedAt });
             return result;
         }
         finally {
@@ -1595,7 +1676,7 @@ async function findExtensionBoundedRoot(file, extensionRootKey) {
         }
         // Stop at or beyond the extensions root — never walk into the
         // pi-agent-wide scope.
-        const currentKey = normalizeSlashKey(currentDir);
+        const currentKey = normalizeEphemeralMapKey(path.resolve(currentDir));
         if (currentKey === extensionRootKey)
             return undefined;
         const parent = path.dirname(currentDir);
@@ -2623,7 +2704,7 @@ export const FishServer = {
     spawn(root, options) {
         return resolveAndLaunch({
             candidates: nodeBinCandidates(root, "fish-lsp"),
-            args: ["start"],
+            args: ["start", "--stdio"],
             cwd: root,
             managedToolId: "fish-lsp",
         }, options?.allowInstall);

package/node_modules/pi-lens/dist/clients/lsp/sync-kind.js

@@ -40,3 +40,17 @@ export function negotiateSyncKind(serverCapabilities) {
     }
     return TEXT_DOCUMENT_SYNC_KIND_FULL;
 }
+export function negotiateSaveOptions(serverCapabilities) {
+    const sync = serverCapabilities?.textDocumentSync;
+    if (!sync || typeof sync !== "object")
+        return undefined;
+    const save = sync.save;
+    if (save === true)
+        return { includeText: false };
+    if (save && typeof save === "object") {
+        return {
+            includeText: save.includeText === true,
+        };
+    }
+    return undefined;
+}

package/node_modules/pi-lens/dist/clients/lsp/wait-policy/strategies.js

@@ -220,8 +220,8 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
         // once the index has already had a full aggregateWaitMs window.
         workspaceIndexing: true,
         workspaceIndexingWarmWaitMs: 250,
-        // #799: marksman is push-only and publishes NOTHING on a clean file —
-        // there is no pull fallback and no sync-confirm protocol (unlike
+        // #799 / run 35914033696: marksman is push-only and publishes NOTHING on
+        // a clean transition — there is no pull fallback and no sync-confirm protocol (unlike
         // typescript's tsserver commands), so a clean markdown file's touch
         // waits its full budget with zero signal either way. Marking it
         // `silentOnClean` lets the generic push-only clean-confirm gate
@@ -243,20 +243,9 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     // diagnostics this strategy governs are a REAL but PARTIAL signal, not
     // full CUE validation.
     //
-    // silentOnClean: true — the load-bearing finding. A cold `didOpen` on an
-    // already-CLEAN file publishes NOTHING inside the wait budget (measured:
-    // `touchFile` returns `inconclusive: true, inconclusiveReason:
-    // "diagnostics-wait"` after the full budget, never an affirmative empty
-    // array). This reproduces the #1520 review's original "reports
-    // conclusively clean while still waiting" concern for the clean-cold-open
-    // case specifically. It is NOT silent on every transition, though: once a
-    // document is open and a `didChange` lands, the server DOES publish —
-    // both the error (edit clean→broken: confirmed, ~930ms warm) and an
-    // explicit empty array clearing it (edit broken→clean: confirmed,
-    // ~320ms warm, `contentHash`-bound). That edit-triggered empty publish is
-    // exactly what the shared push-only clean-confirm gate needs
-    // `silentOnClean` for — it only ever governs the "no publish, notify
-    // succeeded" case, never a case that already got a real publish.
+    // The repaired clean-signal probe measured cue as publishing a versioned
+    // clean-transition set (run 35914033696), so this marker stays absent:
+    // the cascade must retain its normal early-publish path.
     //
     // seedFirstPush: true — the one cold-open case that DOES publish (a
     // file that is already broken) sends the complete single diagnostic on
@@ -267,6 +256,96 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     // (~930ms, syntax reparse) with margin; a cold spawn's first push (~2.1s
     // end-to-end including process start) is bounded separately by
     // maxClientWaitMs, not this per-diagnostics budget.
+    // intelephense (php, #3310). Measured directly against the real v1.18.5
+    // binary over a raw JSON-RPC session answering `workspace/configuration`
+    // the way pi-lens does (2026-09-23, linux):
+    //
+    //   +284ms  initialize response — NO diagnosticProvider (push-only)
+    //   +295ms  publishDiagnostics diags=0  version=undefined   <- pre-index
+    //   +301ms  indexingStarted
+    //   +689ms  indexingEnded
+    //   +696ms  publishDiagnostics diags=2  version=undefined   <- the answer
+    //
+    // so `emptyFirstPublish: "indexing"`: the first publish is an artifact of
+    // the cold index, not an answer. The same session on a genuinely CLEAN
+    // file publishes `[]` at +304ms and `[]` AGAIN at +663ms (right after
+    // `indexingEnded`), which is what lets the held publish be released by
+    // the server's own second publish instead of by a timer — and a WARM
+    // touch (a second file, index already built) publishes the real set
+    // FIRST at +5ms, so the hold costs nothing once the session is warm.
+    //
+    // seedFirstPush: false — the measurement above is the direct refutation
+    // of "the first push is complete" for this server.
+    // pullRetryBudgetMs: 0 — no pull provider is advertised at all.
+    // aggregateWaitMs: 8000 — the budget must cover the cold index window,
+    // which is what the second (real) publish waits on: ~0.4s for a 139-file
+    // index on the dev box, ~5s on the nightly ubuntu runner (#3217's
+    // transcript). Per-edit callers cap this as a CEILING (#242), so an
+    // interactive edit still waits only its own cap; the uncapped paths (the
+    // tool-smoke LSP gate, which itself caps at 8000ms) get the full budget,
+    // and the cold index is paid once per session, not once per touch.
+    php: {
+        seedFirstPush: false,
+        pullRetryBudgetMs: 0,
+        debounceMs: 150,
+        aggregateWaitMs: 8000,
+        expectSemanticSecondPush: false,
+        emptyFirstPublish: "indexing",
+    },
+    // Svelte's pull diagnostics settle after the default 1500ms budget on a
+    // cold server. The tool-smoke gate caps waits at 8000ms, so give this
+    // server enough aggregate budget to return its seeded findings (#3311).
+    svelte: {
+        seedFirstPush: false,
+        pullRetryBudgetMs: 0,
+        debounceMs: 150,
+        aggregateWaitMs: 4000,
+        expectSemanticSecondPush: false,
+    },
+    // csharp-ls loads (design-time-builds) the restored project AFTER
+    // `initialize` returns, so the publish for a seeded CS0029 lands inside
+    // `waitForDiagnostics`, not inside the client wait. MEASURED A/B over two
+    // nightly Tool-smoke runs of the same fixture with `dotnet restore` already
+    // done — the ONLY difference between them was this budget:
+    //   * `aggregateWaitMs` 1500 (the default): run 36054901266 →
+    //     `[csharp] touched=0`, 4.05s after `Restored …/toolsmoke.csproj`.
+    //     A real compiler error read as clean.
+    //   * 8000: run 36058292424 → `[csharp] touched=1`, 6.49s after the same
+    //     line; gate run 36059988117 → `lsp_diagnostics returned 1 primary
+    //     finding`, 4.86s after it.
+    // Both windows INCLUDE workspace bootstrap + spawn + initialize, so they
+    // bound the wait from above: the required budget is in (1500, 4860] ms.
+    // 6000 covers the measured gate window with margin and stays under the
+    // tool-smoke gate's own 8000ms ceiling (that relation is pinned by
+    // tests/config/lsp-gate-population.test.ts), so the gate can still witness
+    // this budget. CONFIRMED at 6000 by run 36064829436: `✓ csharp csharp-ls 1
+    // lsp_diagnostics returned 1 primary finding`, 4.78s after `Restored
+    // …csproj`, census unchanged at gated 31 / handshake-only 8 / unavailable 6
+    // — so 6000 is measured as sufficient, not merely inferred from the 8000
+    // runs above. It is deliberately NOT the ceiling: an `lsp_diagnostics` call
+    // that passes no `waitMs` pays this budget in full on a file the server never
+    // publishes for (`tools/lsp-diagnostics.ts` leaves `maxClientWaitMs`
+    // undefined → `perServerTimeout` has no caller cap), so every 1000ms here
+    // is 1000ms of turn latency on the no-publication path (#3402 review r2).
+    // Every other field is DEFAULT_STRATEGY's value on purpose: csharp-ls is
+    // `mode=pull`/tier-1 authoritative-clean (#3311 investigator table), and
+    // nothing has measured its pull retry, so this entry moves the one field
+    // that was measured and no other (pinned in
+    // tests/clients/lsp/server-strategies.test.ts).
+    // fsharp/expert/vue deliberately have NO entry: the same two runs show
+    // `touched=0` at BOTH 1500 and 8000, so the budget is not what stops them
+    // publishing and an 8000 entry would buy nothing while costing every
+    // uncapped production call 6.5 extra seconds. Their fixture rows carry the
+    // observed-behavior exemption instead (`scripts/smoke-tools.mjs`), and a
+    // probe that wants a long window sets `PI_LENS_LSP_DIAGNOSTICS_MAX_WAIT_MS`
+    // — a flat harness override that needs no production budget.
+    csharp: {
+        seedFirstPush: false,
+        pullRetryBudgetMs: 250,
+        debounceMs: 150,
+        aggregateWaitMs: 6000,
+        expectSemanticSecondPush: false,
+    },
     cue: {
         seedFirstPush: true,
         pullRetryBudgetMs: 0,
@@ -274,6 +353,16 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
         aggregateWaitMs: 2000,
         expectSemanticSecondPush: false,
         reopenOnResync: false,
+    },
+    // lua-language-server is push-only and was silent on clean transitions in
+    // the repaired probe (run 35914033696). Keep the marker on the measured
+    // server id so the cascade can skip its in-lane wait safely.
+    lua: {
+        seedFirstPush: true,
+        pullRetryBudgetMs: 0,
+        debounceMs: 150,
+        aggregateWaitMs: 2000,
+        expectSemanticSecondPush: false,
         silentOnClean: true,
     },
 };