@herbertgao/pi-extensions 2026.9.6 → 2026.9.7

package/node_modules/pi-lens/dist/clients/instance-reaper.js

@@ -70,6 +70,7 @@ import { acquireQuarantinePidFileLock } from "./bounded-pid-file-lock.js";
 import { unrefChildAndPipes, } from "./child-unref.js";
 import { incrementDegradationCount, recordDegradationOnce, } from "./degradation-ledger.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
+import { resolveBackstopStateDir } from "./instance-reaper-state.js";
 import { isInstanceRegistryEnabled, pruneDeadInstances as pruneDeadRegistryInstances, readInstanceRegistry, } from "./instance-registry.js";
 import { logLatency } from "./latency-logger.js";
 import { queryProcessTable, windowsExe } from "./process-snapshot.js";
@@ -717,7 +718,7 @@ function matchesManagedBinary(command) {
 export async function sweepUntrackedOrphans(options = {}) {
     const startedAt = Date.now();
     if (!isInstanceRegistryEnabled()) {
-        return logBackstopOutcome("disabled", startedAt, {});
+        return logBackstopOutcome("disabled", startedAt, {}, options.onComplete);
     }
     const cooldownMs = Math.max(0, options.cooldownMs ?? BACKSTOP_COOLDOWN_MS);
     let release = null;
@@ -735,13 +736,13 @@ export async function sweepUntrackedOrphans(options = {}) {
             // Another process holds the sweep right now. Not an error, and not a
             // cooldown either — a distinct record, because "somebody else is
             // sweeping" and "we swept recently" have different causes.
-            return logBackstopOutcome("concurrent", startedAt, {});
+            return logBackstopOutcome("concurrent", startedAt, {}, options.onComplete);
         }
         const throttled = await isWithinCooldown(Date.now(), cooldownMs, options);
         if (throttled !== undefined) {
             return logBackstopOutcome("cooldown", startedAt, {
                 sinceLastMs: throttled,
-            });
+            }, options.onComplete);
         }
         // Claim the cooldown slot BEFORE the scan, not after: a sweep that dies
         // mid-scan must not re-run at full cost on every retry.
@@ -766,7 +767,7 @@ export async function sweepUntrackedOrphans(options = {}) {
                 scanStatus: scan.status,
                 scannerKill: scan.timeoutKill,
                 scanned: scan.processes.length,
-            });
+            }, options.onComplete);
         }
         const partition = partitionBackstopCandidates(scan.processes, registry, realIsPidAlive, { graceMs: options.graceMs });
         for (const proc of partition.unknownAge) {
@@ -811,7 +812,7 @@ export async function sweepUntrackedOrphans(options = {}) {
             killedProcesses: killed.slice(0, BACKSTOP_IDENTITY_LOG_LIMIT),
             unverifiedProcesses: unverified.slice(0, BACKSTOP_IDENTITY_LOG_LIMIT),
             graceRetryInMs: retryAt,
-        });
+        }, options.onComplete);
     }
     catch (error) {
         // The sweep must never throw out of session_start — but "threw" is now
@@ -821,7 +822,7 @@ export async function sweepUntrackedOrphans(options = {}) {
             subject: "sweep",
             reason: `sweep threw: ${error instanceof Error ? error.message : String(error)}`,
         });
-        return logBackstopOutcome("error", startedAt, { threw: true });
+        return logBackstopOutcome("error", startedAt, { threw: true }, options.onComplete);
     }
     finally {
         if (release) {
@@ -909,13 +910,14 @@ function scheduleGraceRetryIfNeeded(partition, options) {
         force: true,
         allowGraceRetry: false,
     });
+    options.onGraceRetryScheduled?.(delayMs);
     return delayMs;
 }
 /** Serialize the sweep across processes. Returns null when another process
  *  holds it — the caller skips rather than waits (`waitMs: 0`). */
 async function acquireBackstopLock() {
     try {
-        return await acquireQuarantinePidFileLock(path.join(getGlobalPiLensDir(), "orphan-backstop.lock"), {
+        return await acquireQuarantinePidFileLock(path.join(resolveBackstopStateDir(getGlobalPiLensDir()), "orphan-backstop.lock"), {
             waitMs: 0,
             retryMs: 50,
             staleMs: BACKSTOP_LOCK_STALE_MS,
@@ -952,7 +954,7 @@ function describeManagedProcess(proc) {
     const matched = MANAGED_BINARY_NAMES.find((name) => lower.includes(name.toLowerCase()));
     return `${matched ?? "unknown"}#${proc.pid}`;
 }
-function logBackstopOutcome(outcome, startedAt, metadata) {
+function logBackstopOutcome(outcome, startedAt, metadata, onComplete) {
     try {
         logLatency({
             type: "phase",
@@ -965,13 +967,19 @@ function logBackstopOutcome(outcome, startedAt, metadata) {
     catch {
         // best-effort logging only
     }
+    try {
+        onComplete?.(outcome);
+    }
+    catch {
+        // Test observers must not alter the best-effort sweep outcome.
+    }
     return outcome;
 }
 /** Machine-wide cooldown stamp. A file, not a module-level flag: the sweep is
  *  machine-scoped (every pi-lens process shares one OS process table), and
  *  process-lifetime state cannot express "30 minutes have passed". */
 function backstopStampPath() {
-    return path.join(getGlobalPiLensDir(), "orphan-backstop.json");
+    return path.join(resolveBackstopStateDir(getGlobalPiLensDir()), "orphan-backstop.json");
 }
 async function readBackstopStamp() {
     try {
@@ -990,7 +998,9 @@ async function readBackstopStamp() {
 }
 async function writeBackstopStamp(at) {
     try {
-        await fs.promises.mkdir(getGlobalPiLensDir(), { recursive: true });
+        await fs.promises.mkdir(resolveBackstopStateDir(getGlobalPiLensDir()), {
+            recursive: true,
+        });
         await writeFileAtomicAsync(backstopStampPath(), JSON.stringify({ lastSweepAt: at }));
     }
     catch {

package/node_modules/pi-lens/dist/clients/language-profile.js

@@ -52,6 +52,8 @@ const PROJECT_MARKERS_BY_KIND = {
 };
 const ROOT_MARKERS_BY_KIND = {
     jsts: [
+        "biome.json",
+        "biome.jsonc",
         "package.json",
         "tsconfig.json",
         "jsconfig.json",
@@ -100,6 +102,26 @@ const ROOT_MARKERS_BY_KIND = {
     csharp: DOTNET_CSHARP_ROOT_MARKERS,
     fsharp: DOTNET_FSHARP_ROOT_MARKERS,
 };
+// Tool-owned configuration belongs beside the shared language vocabulary, but
+// not in ROOT_MARKERS_BY_KIND: these files are discovered by the tool, not by
+// the language root detector. Keeping them here lets runner cwd resolution
+// consume one canonical vocabulary without restoring a second seam-local map.
+const TOOL_MARKERS_BY_RUNNER = {
+    ruff: ["ruff.toml", ".ruff.toml"],
+    oxlint: [".oxlintrc.json", "oxlint.config.js"],
+    "spellcheck/typos": ["_typos.toml", "typos.toml"],
+    yamllint: ["yamllint.yaml", "yamllint.yml"],
+    prettier: [".prettierignore"],
+};
+/** Return the one shared marker vocabulary used to anchor this file kind. */
+export function rootMarkersForFile(filePath, runner) {
+    const kind = detectFileKind(path.resolve(filePath));
+    const languageMarkers = kind ? (ROOT_MARKERS_BY_KIND[kind] ?? []) : [];
+    const toolMarkers = runner ? (TOOL_MARKERS_BY_RUNNER[runner] ?? []) : [];
+    return toolMarkers.length
+        ? [...new Set([...languageMarkers, ...toolMarkers])]
+        : languageMarkers;
+}
 function hasProjectMarker(projectRoot, marker) {
     if (!marker.includes("*"))
         return fs.existsSync(path.join(projectRoot, marker));
@@ -192,7 +214,7 @@ export function resolveLanguageRootForFile(filePath, workspaceRoot) {
     const kind = detectFileKind(absoluteFilePath);
     if (!kind)
         return path.resolve(workspaceRoot);
-    const markers = ROOT_MARKERS_BY_KIND[kind];
+    const markers = rootMarkersForFile(absoluteFilePath);
     if (!markers || markers.length === 0) {
         return path.resolve(workspaceRoot);
     }

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

@@ -147,7 +147,9 @@ export const LANGUAGES = [
         id: "cpp",
         kind: "cxx",
         // The clang extension table (file-kinds.ts KIND_EXTENSIONS.cxx) minus the
-        // C header/source pair, which the `c` entry owns.
+        // C header/source pair, which the `c` entry owns. `.cuh` deliberately
+        // diverges from clang's table: CUDA/HIP projects use it for C++ headers,
+        // so it must reach the same cpp grammar and clangd path as `.cu`/`.hip`.
         extensions: [
             ".c++",
             ".c++m",
@@ -158,6 +160,7 @@ export const LANGUAGES = [
             ".cpp",
             ".cppm",
             ".cu",
+            ".cuh",
             ".cxx",
             ".cxxm",
             ".hh",
@@ -182,6 +185,7 @@ export const LANGUAGES = [
             ".cc",
             ".cpp",
             ".cu",
+            ".cuh",
             ".cxx",
             ".hh",
             ".hip",

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

@@ -682,7 +682,10 @@ export function logLatency(entry) {
     if (entry.type === "phase" &&
         entry.phase &&
         !LAST_PHASE_EXCLUDED.has(entry.phase)) {
-        recentPhases = [{ phase: entry.phase, ts }, ...recentPhases].slice(0, RECENT_PHASE_CAP);
+        recentPhases = [
+            { phase: entry.phase, ts, metadata: entry.metadata },
+            ...recentPhases,
+        ].slice(0, RECENT_PHASE_CAP);
     }
     if (isTestMode()) {
         return;

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

@@ -25,6 +25,7 @@ import { acquireWarmWordIndex } from "./mcp/analyze.js";
 import { normalizeMapKey } from "./path-utils.js";
 import { scanProjectDiagnostics } from "./project-diagnostics/scanner.js";
 import { loadProjectSnapshotWithoutWordIndex } from "./project-snapshot.js";
+import { resolveLensToolName } from "./tool-config.js";
 import { getTreeSitterRuntimeStatus, } from "./tree-sitter-shared.js";
 import { centralityFromReverseDeps, getWordIndexBuildStatus, searchWordIndex, triggerBackgroundWordIndexBuild, } from "./word-index.js";
 // --- Facades (re-exported so adapters import only this module) ---------------
@@ -116,7 +117,7 @@ export function scanTruncationNotice(snapshot) {
  *
  * Returns `undefined` when neither counter is set (nothing to append).
  */
-export function generatedSkipNotice(snapshot) {
+export function generatedSkipNotice(snapshot, host = "pi") {
     const files = snapshot.generatedNameOnlySkips ?? 0;
     const dirs = snapshot.generatedDirSkips ?? 0;
     if (files === 0 && dirs === 0)
@@ -126,11 +127,19 @@ export function generatedSkipNotice(snapshot) {
         parts.push(`${files} file(s)`);
     if (dirs > 0)
         parts.push(`${dirs} director${dirs === 1 ? "y" : "ies"}`);
+    // #2535 F1: name the tools THIS host can call. pi has no project-scan
+    // surface, so it names only its diagnostics tool; MCP names both. A
+    // known-but-unmapped host resolves to undefined and is left out, never
+    // printed as a name the host cannot resolve.
+    const targets = [
+        resolveLensToolName("project_scan", host),
+        resolveLensToolName("lens_diagnostics", host),
+    ].filter((tool) => tool !== undefined);
+    const scanRef = targets.length > 0 ? ` to ${targets.join(" / ")}` : "";
     return (`ℹ ${parts.join(" and ")} excluded by generated-name heuristics with no ` +
         "confirming evidence — a real hand-written file/directory whose name " +
         "looks generated (e.g. `gen.ts`, `generated/`) can be excluded too; " +
-        "pass includeGenerated: true to pilens_project_scan / lens_diagnostics " +
-        "to scan without this filter if you suspect a false skip.");
+        `pass includeGenerated: true${scanRef} to scan without this filter if you suspect a false skip.`);
 }
 /** Process-wide tree-sitter health for host status surfaces. */
 export function treeSitterRuntimeStatus() {

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

@@ -50,7 +50,8 @@ export function _resetForTests() {
 function emitLensEvent(eventName, payload) {
     setImmediate(() => {
         const rawCwd = payload.cwd ?? process.cwd();
-        // M1: normalizeFilePath is a sync realpathSync.native on Windows — build
+        // M1: normalizeFilePath is a sync realpathSync.native on Windows, and on
+        // POSIX too since #3098 — build
         // the resolveLiveBusEmitter log entry lazily so the ready-path (the
         // common case) never pays it. Only the stale-session branch needs it.
         const resolution = resolveLiveBusEmitter(liveEmitter, () => ({

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

@@ -173,6 +173,22 @@ export const LENS_FLAGS = [
         default: false,
         scope: "global",
     },
+    {
+        name: "lens-compact-lsp-status",
+        description: "Opt-in (#3099): collapse the footer LSP status to one state glyph per group (LSP ✓ green, LSP ✗ red, dim LSP ✗ when nothing is warm) instead of listing the active server names. Default off. Also via ui.compactLspStatus=true in ~/.pi-lens/config.json.",
+        configKey: "ui.compactLspStatus",
+        negated: false,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "lens-hide-lsp-status",
+        description: "Opt-in (#3099): publish no pi-lens-lsp footer status at all, so a host that renders extension statuses stops showing the key. Outranks lens-compact-lsp-status when both are set. Default off. Also via ui.hideLspStatus=true in ~/.pi-lens/config.json.",
+        configKey: "ui.hideLspStatus",
+        negated: false,
+        default: false,
+        scope: "global",
+    },
     {
         name: "no-lazy-tools",
         description: "Keep all pi-lens tools active to avoid tool-list cache changes. Also via tools.lazy=false in ~/.pi-lens/config.json.",
@@ -235,6 +251,40 @@ export const GLOBAL_NON_FLAG_CONFIG_SECTIONS = [
     "startup",
     "$schema",
 ];
+/**
+ * Dotted GLOBAL-only config keys that are NOT `LENS_FLAGS` entries — no CLI
+ * flag, not a boolean — but still sit inside a section a project
+ * `.pi-lens.json` is otherwise recognized to touch (#3131). The project
+ * loader's mixed-scope sub-key scan (`project-lens-config.ts`) already derives
+ * its FLAG population from `LENS_FLAGS`; that derivation structurally cannot
+ * see a key like `actionableWarnings.autoFix.maxFixes` — a numeric cap with no
+ * `--flag` counterpart, documented global-only (`docs/settings.md`), read only
+ * through `getGlobalActionableWarningMaxFixes()` (`clients/lens-config.ts`) —
+ * because it was never a `LensFlagSpec` to begin with. `actionableWarnings` is
+ * itself recognized at project scope only because its SIBLING
+ * `actionableWarnings.autoFix.enabled` is a `scope: "project"` flag, so before
+ * this registry existed the loader parsed `maxFixes` away with no signal at
+ * all — the same silent-drop shape #2426 review round 2 (F3) fixed for
+ * `lsp.enabled` and #3112 fixed for `tools.lazy`.
+ *
+ * This is the single source that population is derived from: the mixed-scope
+ * scan reads `LENS_FLAGS` for flag keys and this list for everything else, so
+ * a future non-flag global-only key needs one line HERE, never a second
+ * hand-typed list inside the loader.
+ *
+ * A key belongs here ONLY when all three hold: (a) it is global-only — read
+ * solely off `~/.pi-lens/config.json`, never honored from a project document;
+ * (b) it is not a `LENS_FLAGS` entry; (c) its SECTION is recognized at project
+ * scope for some OTHER reason. A key whose whole section is unrecognized at
+ * project scope needs no entry — the top-level unknown-key scan already
+ * reports the section. Swept at #3131: every other non-flag dotted key either
+ * loader parses (`dispatch.runnerTimeoutFloorMs`, `widget.visible`,
+ * `startup.mode`, `startup.scans.enabled`) fails (a) or (c) — see that PR's
+ * body for the per-member table — so this is currently the only member.
+ */
+export const GLOBAL_ONLY_NON_FLAG_KEYS = [
+    "actionableWarnings.autoFix.maxFixes",
+];
 /**
  * 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
@@ -256,6 +306,19 @@ export const PROJECT_NON_FLAG_CONFIG_SECTIONS = [
     "trivy",
     "helm",
     "startup",
+    // `tools` is MIXED-SCOPE, and belongs here for the project-scoped half
+    // (#3112). `tools.<name>.enabled` is not a registry flag at all: it is
+    // hand-parsed by `readToolConfig` against `TOOL_REGISTRY` in BOTH loaders,
+    // and `resolveLensToolEnabled` reads the project document's value ahead of
+    // the global one — which is what `docs/settings.md` and
+    // `docs/globalconfig.md` document. Deriving the project-accepted sections
+    // from the flag registry alone therefore put the whole section in
+    // `globalScopeOnlyKeys` (its only registry flag, `tools.lazy`, IS global)
+    // and told every user of a documented per-tool override that it was being
+    // ignored. The global-only half is not lost: `tools.lazy` is still reported
+    // at project scope by the project loader's mixed-scope sub-key scan, which
+    // derives WHICH sub-keys those are from this same registry.
+    "tools",
 ];
 /**
  * The four LSP settings a PROJECT config file may carry — at its root during
@@ -343,6 +406,22 @@ function resolveFlagConfigPath(raw, configKey, warnInvalid) {
         return undefined;
     return { source: finalSource, segments };
 }
+/**
+ * Whether a parsed config document actually SETS the dotted `configKey` —
+ * presence, not validity (#3112). The project loader's mixed-scope scan must
+ * report `tools: { lazy: "yes" }` exactly as it reports `tools: { lazy: false }`:
+ * the user wrote a global-only setting in a project file either way, and
+ * {@link readFlagConfigValue} would return `undefined` for the malformed one and
+ * silently skip it. Shares {@link resolveFlagConfigPath} with every other reader
+ * so "which segments does this key name" is answered in exactly one place.
+ */
+export function hasFlagConfigPath(raw, configKey) {
+    const resolved = resolveFlagConfigPath(raw, configKey);
+    if (!resolved)
+        return false;
+    const leaf = resolved.segments.at(-1);
+    return leaf !== undefined && leaf in resolved.source;
+}
 /**
  * Read the boolean at a spec's dotted `configKey` out of an already-parsed
  * config object. Returns undefined when any segment is missing or the leaf is

package/node_modules/pi-lens/dist/clients/live-bus-emitter.js

@@ -54,7 +54,8 @@ export function createLiveBusEmitter() {
  *
  * `entry` is a THUNK, not a value (M1, #1415 review): building the log entry
  * (every producer's version normalizes `cwd` via `normalizeFilePath`, a sync
- * `realpathSync.native` call on Windows) is real per-publish cost that used
+ * `realpathSync.native` call on Windows and, since #3098, on POSIX too) is
+ * real per-publish cost that used
  * to be paid on EVERY call regardless of outcome, even though it is only
  * consumed on the `stale-session` branch. Invoking the thunk only there means
  * the common `ready` path pays nothing for it.

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

@@ -15,6 +15,7 @@ import { pathToFileURL } from "node:url";
 import { emitBounded } from "../bounded-telemetry.js";
 import { withTimeout } from "../deadline-utils.js";
 import { minimatch } from "../deps/minimatch.js";
+import { mapWithConcurrency } from "../map-with-concurrency.js";
 import { incrementDegradationCount, recordDegradationOnce, } from "../degradation-ledger.js";
 // vscode-jsonrpc v9 ships an `exports` map exposing the Node entry as the
 // `./node` subpath (no `.js`); the old `/node.js` file path no longer resolves.
@@ -25,7 +26,7 @@ import { workspaceDiagnosticsCacheSessionStart } from "./workspace-diagnostics-s
 import { logLatency } from "../latency-logger.js";
 import { newLspMutationCorrelationId, } from "../lsp-mutation.js";
 import { getProcessSingleton } from "../process-singletons.js";
-import { getAmbientAbortSignal } from "../safe-spawn.js";
+import { getAmbientAbortSignal, isOwnLiveChild, releaseOwnChildPid, } from "../safe-spawn.js";
 import { raceToCompletion } from "./aggregation.js";
 import { hashDiagnosticContent, } from "./diagnostic-binding.js";
 import { applyWorkspaceEdit, normalizeWorkspaceEditToUtf16 } from "./edits.js";
@@ -216,25 +217,6 @@ const WORKSPACE_PULL_SCOPE = "*workspace*";
 // load. Small and fixed — this is a background improvement after the
 // protocol reply, never something worth tuning per project.
 const REFRESH_REPULL_CONCURRENCY = 4;
-/** Run `mapper` over `items` with at most `concurrency` in flight at once.
- *  Same shape as `dependency-checker.ts`'s helper of the same name — a
- *  worker-pool pattern repeated per-file by design in this codebase rather
- *  than shared, so each caller can keep it un-exported and file-local. */
-async function mapWithConcurrency(items, concurrency, mapper) {
-    if (items.length === 0)
-        return;
-    let nextIndex = 0;
-    const workerCount = Math.max(1, Math.min(concurrency, items.length));
-    const worker = async () => {
-        while (true) {
-            const index = nextIndex++;
-            if (index >= items.length)
-                return;
-            await mapper(items[index]);
-        }
-    };
-    await Promise.all(Array.from({ length: workerCount }, () => worker()));
-}
 // Anti-deadlock backstop for workspace/executeCommand. Deliberately generous
 // (30s): the command is mutating and legitimately long-running (a real server
 // refactor / organize-imports), so this must not truncate valid work — it only
@@ -383,6 +365,9 @@ export async function killProcessTree(proc, pid, options = {}) {
     // the handle-based proc.kill() below is moot, so return early.
     if ((proc.exitCode != null || proc.signalCode != null) &&
         !options.processExiting) {
+        // #3091 F1-r2b: this pid will never be signalled again, so retire the
+        // ownership hold taken at spawn rather than leaving it to age out.
+        releaseOwnChildPid(pid);
         proc.unref?.();
         return;
     }
@@ -458,7 +443,20 @@ export async function killProcessTree(proc, pid, options = {}) {
         return;
     }
     const killPosixProcessGroup = (signal) => {
-        if (pid <= 0)
+        // #2042: one ownership predicate for every kill-by-raw-pid, replacing
+        // the `pid <= 0` sign check that let a test double's invented pid
+        // through. A pid we do not own falls back to `killDirectChild` below,
+        // which signals through the retained handle and can only ever reach
+        // our own child.
+        //
+        // #3091 F1: `proc` is deliberately NOT passed. The handle arm means
+        // "already exited ⇒ refuse", and this group kill must still fire when
+        // the direct child is dead — the early return at :1269 is skipped under
+        // `options.processExiting`, and a POSIX group outlives its leader, so
+        // the group signal is the only thing that reaps surviving grandchildren
+        // at host exit (#2026). Ownership here comes from the kernel and, once
+        // the leader is gone, from the verdict recorded while it was alive.
+        if (!isOwnLiveChild(pid, "lsp-stop-posix-group"))
             return false;
         try {
             process.kill(-pid, signal);
@@ -516,6 +514,11 @@ export async function killProcessTree(proc, pid, options = {}) {
                         killDirectChild("SIGKILL");
                     }
                 }
+                // AFTER the escalation, never before it: this tick issues the
+                // last signal this pid can receive, and retiring the ownership
+                // hold first would make that very SIGKILL the thing that gets
+                // refused (#3091 F1-r2b).
+                releaseOwnChildPid(pid);
             }, 1500);
             timer.unref?.();
             proc.unref?.();
@@ -553,6 +556,7 @@ export async function killProcessTree(proc, pid, options = {}) {
                 killDirectChild("SIGKILL");
             }
         }
+        releaseOwnChildPid(pid);
     }
     catch {
         // ignore

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

@@ -344,8 +344,8 @@ export function createCustomServer(config, id) {
             ? async (file) => resolveToolCwd("lsp", id, file, {
                 cwd: process.cwd(),
                 ...(config.rootMarkers ? { rootMarkers: config.rootMarkers } : {}),
-            })
-            : async (file) => resolveToolCwd("lsp", id, file, { cwd: process.cwd() }),
+            }).cwd
+            : async (file) => resolveToolCwd("lsp", id, file, { cwd: process.cwd() }).cwd,
         async spawn(root) {
             const proc = await launchLSP(config.command, config.args ?? ["--stdio"], {
                 cwd: root,

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

@@ -7390,9 +7390,16 @@ export class LSPService {
                 // duplicating what the per-edit path already suppresses. `content`
                 // was already read above for this file, so `detectFileRole` gets the
                 // higher-accuracy content-aware classification at no extra cost.
+                // #3041: `filePath`/`scanRoot` additionally apply each rule's own
+                // `ignores` carve-out (#965). ast-grep's LSP does NOT apply it to the
+                // per-document diagnostics it publishes (only its own `scan` walk
+                // does), so without this the sweep re-surfaces exactly what the NAPI
+                // runner skips on the same file.
                 const filteredDiagnostics = diagnostics
                     ? applyAuxiliarySuppressions(diagnostics, content, {
                         fileRole: detectFileRole(filePath, content),
+                        filePath,
+                        scanRoot: root,
                     })
                     : diagnostics;
                 results.push({

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

@@ -16,7 +16,7 @@ import { getGlobalPiLensLogDir } from "../probe-home-state.js";
 import { isFullyQualified } from "../path-utils.js";
 import { findGlobalBinary } from "../package-manager.js";
 import { redactSecrets } from "../redact/secrets.js";
-import { classifySpawnFailure, SpawnFailureError } from "../safe-spawn.js";
+import { classifySpawnFailure, holdOwnChildPid, isOwnLiveChild, SpawnFailureError, } from "../safe-spawn.js";
 import { getRubyVersionDirNamesAsync } from "./ruby-drive-dirs.js";
 const isWindows = process.platform === "win32";
 /**
@@ -327,6 +327,14 @@ function trySpawn(command, args, cwd, env, needsShell) {
         throw new Error(`LSP server ${command} exited immediately (code: ${proc.exitCode}). ` +
             `The binary may be missing or corrupted.`);
     }
+    // #3091 F1-r2: take ownership HERE, while the child is provably alive. LSP
+    // servers are the one long-lived child pi-lens spawns outside
+    // `safeSpawnAsync`, so without this their first offer of verification is
+    // `stopLSP`'s group kill — by which time, on the `processExiting` path, the
+    // leader can already be dead, `/proc` is gone, and the group signal that
+    // reaps surviving grandchildren (#2026) is refused. The verdict is released
+    // by `killProcessTree` when the shutdown ladder is done with the pid.
+    holdOwnChildPid(proc.pid, "lsp-spawn");
     return proc;
 }
 /**
@@ -654,7 +662,7 @@ export async function stopLSP(handle) {
         handle.process.once("exit", done);
         handle.process.once("error", done);
         const killWindowsTree = () => {
-            if (!isWindows || handle.pid <= 0)
+            if (!isWindows)
                 return false;
             // If our child has already exited, its PID is dead and the OS may have
             // RECYCLED it to an unrelated process. `taskkill /F /T` on a recycled PID
@@ -665,8 +673,12 @@ export async function stopLSP(handle) {
             // tree-kill a PID we no longer own — fall back to handle.process.kill(),
             // which on Windows signals via the retained process HANDLE (not the raw
             // PID), so it's a safe no-op on an already-exited child.
-            if (handle.process.exitCode !== null ||
-                handle.process.signalCode !== null)
+            //
+            // #2042 folded the sign check and this exited check into the one
+            // ownership predicate every kill-by-raw-pid now shares; the handle
+            // arm below IS this paragraph, and on Windows it is the only
+            // ownership evidence available (there is no /proc to read).
+            if (!isOwnLiveChild(handle.pid, "lsp-stop-windows-tree", handle.process))
                 return false;
             try {
                 // Absolute path avoids PATH-resolution substitution on Windows.

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

@@ -15,6 +15,7 @@ import { augmentPythonEnvironment, detectPythonEnvironment, detectPythonVenv, py
 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 { ensureTool, findManagedToolBinary, getToolEnvironment, getToolPath, } from "../installer/index.js";
 import * as installer from "../installer/index.js";
@@ -71,14 +72,14 @@ export async function resolveLspServerCwd(server, filePath, sessionCwd, onRootFa
         return resolveToolCwd("lsp", server.id, filePath, {
             cwd: path.dirname(path.resolve(filePath)),
             rootMarkers,
-        });
+        }).cwd;
     }
     const boundedServerRoot = enforceLspRootCeiling(serverRoot, sessionCwd, filePath);
     return resolveToolCwd("lsp", server.id, filePath, {
         cwd: sessionCwd,
         rootMarkers,
         serverRoot: boundedServerRoot,
-    });
+    }).cwd;
 }
 const FIXTURE_ROOT_SEGMENTS = new Set(["__fixtures__", "testdata"]);
 const FALLBACK_PROJECT_MARKERS = [
@@ -2493,6 +2494,21 @@ export const GleamServer = {
         }, options?.allowInstall);
     },
 };
+export const TinymistServer = {
+    id: "tinymist",
+    name: "Tinymist",
+    extensions: extensionsForLanguage("typst"),
+    root: RootWithFallback(createRootDetector(["typst.toml", ".git"])),
+    availabilityKey: "tinymist",
+    async spawn(root, options) {
+        return resolveAndLaunch({
+            candidates: ["tinymist"],
+            args: ["lsp"],
+            cwd: root,
+            managedToolId: "tinymist",
+        }, options?.allowInstall);
+    },
+};
 export const MarksmanServer = {
     id: "marksman",
     name: "Marksman",
@@ -3146,6 +3162,7 @@ export const LSP_SERVERS = [
     ElixirServer,
     ElixirExpertServer,
     GleamServer,
+    TinymistServer,
     MarksmanServer,
     OCamlServer,
     ClojureServer,

package/node_modules/pi-lens/dist/clients/lsp/workspace-diagnostics-cache.js

@@ -150,7 +150,8 @@ export function clearWorkspaceDiagnosticsCacheAtAndAbove(cwd, ceiling = process.
 //   "recompute", the same outcome a real refresh produces. The pre-#1754 map
 //   was unbounded; the bound is new and costs at most one extra sweep for a
 //   cwd that fell off the end.
-// - `normalizeMapKey` runs `realpathSync.native` on Windows. A handle re-runs
+// - `normalizeMapKey` runs `realpathSync.native` on Windows and, since #3098,
+//   on POSIX as well. A handle re-runs
 //   it only after the map has been invalidated, so an uninterrupted sweep pays
 //   that syscall once at context creation rather than once per `lookup()`, and
 //   an interrupted one pays it per check to stay correct if the cwd's realpath

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

@@ -85,9 +85,11 @@ function uniqueDetails(files, fileDetails) {
     const byPath = new Map();
     // #2016: `files` and `fileDetails` name the same paths, so without this the
     // map-build loop and the lookup below each pay `realpathSync.native` for the
-    // same path (~200 microseconds per call on Windows; POSIX short-circuits, so
-    // CI cannot see it). The memo lives for one call, so it has no staleness
-    // window at all and needs no freshness design.
+    // same path (~200 microseconds per call on Windows; since #3098 POSIX pays it
+    // too, measured at 1.8 microseconds for an existing path — still under any CI
+    // timing gate, so the waste stays invisible either way). The memo lives for
+    // one call, so it has no staleness window at all and needs no freshness
+    // design.
     const keyMemo = new Map();
     const keyFor = (filePath) => {
         let key = keyMemo.get(filePath);