@herbertgao/pi-extensions 2026.8.11 → 2026.8.13

package/node_modules/pi-lens/dist/clients/runtime-turn.js

@@ -31,6 +31,10 @@ import { formatRunDurationMs } from "./run-duration.js";
 import { MAX_ADVISORY_AFFECTED_FILES, gateFindingsByPathFreshness, snapshotAdvisoryProvenance, } from "./advisory-provenance.js";
 import { sweepInlineBlockerFreshness } from "./blocker-freshness.js";
 import { sweepInlineBlockerPastEof } from "./blocker-past-eof.js";
+// #2001/#2002: collect-later delivery for slow auxiliary LSP servers.
+import { getLSPService } from "./lsp/index.js";
+import { drainPendingAuxiliaryCoverage, isPendingAuxiliaryPastRearmTtl, markPendingAuxiliaryCoverage, } from "./lsp/pending-aux-coverage.js";
+import { convertLspDiagnostics } from "./dispatch/utils/lsp-diagnostics.js";
 // #1631 review V2: moved to its own leaf module so a low-level store
 // (widget-state.ts) can use the marker without importing this orchestrator —
 // see clients/stale-marker.ts's doc comment.
@@ -267,7 +271,8 @@ export async function handleTurnEnd(deps) {
         dbg(`turn_end: foreign live owner retained (${turnState.owner?.kind ?? "legacy"}:${turnState.owner?.id ?? turnState.sessionId})`);
         return;
     }
-    if (access === "available" && (turnState.files || turnState.owner || turnState.sessionId)) {
+    if (access === "available" &&
+        (turnState.files || turnState.owner || turnState.sessionId)) {
         dbg("turn_end: evicting stale turn-state owner");
         cacheManager.clearTurnState(cwd, currentOwner);
         turnState = cacheManager.readTurnState(cwd);
@@ -583,7 +588,9 @@ export async function handleTurnEnd(deps) {
                 neighborCount: uniqueNeighborFiles.length,
                 metadata: {
                     neighborFiles: uniqueNeighborFiles.slice(0, 10),
-                    suggestedTestFiles: testSuggestions.slice(0, 10).map((s) => s.testFile),
+                    suggestedTestFiles: testSuggestions
+                        .slice(0, 10)
+                        .map((s) => s.testFile),
                     runner: testSuggestions[0]?.runner,
                     truncated: testSuggestions.length > 10,
                     zeroSuggestions: testSuggestions.length === 0,
@@ -1461,9 +1468,12 @@ export async function handleTurnEnd(deps) {
                     generation: testRunGeneration,
                     files: provenanceFiles,
                 });
-                const superseded = launchedFrom.revision.sessionId !== publishedAgainst.revision.sessionId ||
-                    launchedFrom.revision.projectSeq !== publishedAgainst.revision.projectSeq ||
-                    launchedFrom.revision.turnIndex !== publishedAgainst.revision.turnIndex ||
+                const superseded = launchedFrom.revision.sessionId !==
+                    publishedAgainst.revision.sessionId ||
+                    launchedFrom.revision.projectSeq !==
+                        publishedAgainst.revision.projectSeq ||
+                    launchedFrom.revision.turnIndex !==
+                        publishedAgainst.revision.turnIndex ||
                     launchedFrom.files.some((file, index) => publishedAgainst.files[index]?.sha256 !== file.sha256 ||
                         publishedAgainst.files[index]?.path !== file.path);
                 // #628: the turn advancing while tests ran no longer means the
@@ -1516,6 +1526,13 @@ export async function handleTurnEnd(deps) {
                     // git-guard blocker. `formatResult` already renders the
                     // error-only case as "Could not run tests: ...".
                     if (failed > 0 || error) {
+                        // #2028: "Test file not found" is an expected skip
+                        // (conventional test path without an actual file),
+                        // not an actionable failure. Don't surface it.
+                        if (error &&
+                            String(r.value?.error ?? "").includes("Test file not found")) {
+                            continue;
+                        }
                         const formatted = testRunnerClient.formatResult(r.value);
                         if (formatted)
                             failures.push(formatted);
@@ -1541,7 +1558,8 @@ export async function handleTurnEnd(deps) {
                         provenance: publishedAgainst,
                         superseded,
                     }, cwd);
-                    if (getFlag("lens-guard") && firedSessionId === runtime.telemetrySessionId) {
+                    if (getFlag("lens-guard") &&
+                        firedSessionId === runtime.telemetrySessionId) {
                         // #1524: `&& !value.error` — a runner-error result has
                         // `failed === 0` (the suite never ran, so nothing could
                         // fail), but it is not a pass. Without the filter it
@@ -1791,6 +1809,129 @@ export async function handleTurnEnd(deps) {
         });
     }
     cacheManager.incrementTurnCycle(cwd, currentOwner);
+    // #2001/#2002: collect-later delivery for auxiliary LSP servers whose
+    // aux-grace window expired without a publication (opengrep on Windows:
+    // ~8s per scan against a 2s grace — the scanner's eventual findings sat
+    // in its client cache, agent-invisible). Probe each pending pair through
+    // the read-only cache seam (never spawns), freshness-gate the result
+    // against when the pair was marked, and deliver survivors as an advisory.
+    // A pair whose client is alive but has STILL published nothing re-arms
+    // (baseline preserved, TTL anchor advanced) until the re-arm TTL; a dead
+    // client drops silently.
+    const lateAuxStart = Date.now();
+    const drainedPairs = drainPendingAuxiliaryCoverage();
+    let lateAuxDelivered = 0;
+    let lateAuxStale = 0;
+    let lateAuxMissing = 0;
+    let lateAuxRearmed = 0;
+    let lateAuxClientGone = 0;
+    let lateAuxProbeFailed = 0;
+    if (drainedPairs.length > 0) {
+        const byFile = new Map();
+        for (const pair of drainedPairs) {
+            const list = byFile.get(pair.filePath);
+            if (list)
+                list.push(pair);
+            else
+                byFile.set(pair.filePath, [pair]);
+        }
+        try {
+            const service = getLSPService();
+            for (const [lateAuxPath, pairs] of byFile) {
+                let cached;
+                try {
+                    cached = await service.readCachedDiagnosticsForServers(lateAuxPath, new Set(pairs.map((p) => p.serverId)));
+                }
+                catch {
+                    // #2027 round-1 P3-2: count dropped pairs — never silent.
+                    lateAuxProbeFailed += pairs.length;
+                    for (const pair of pairs) {
+                        markPendingAuxiliaryCoverage(pair.filePath, [pair.serverId], Date.now());
+                    }
+                    continue;
+                }
+                const displayLateAuxPath = toRunnerDisplayPath(cwd, lateAuxPath);
+                for (const pair of pairs) {
+                    const rawDiags = cached.get(pair.serverId);
+                    if (rawDiags === undefined) {
+                        // No live client for this server any more — best-effort probe,
+                        // drop the pair silently.
+                        lateAuxClientGone += 1;
+                        continue;
+                    }
+                    if (rawDiags.length === 0) {
+                        // Still scanning (or published nothing yet) — keep waiting
+                        // so a scan finishing before the NEXT turn end still
+                        // delivers. Two clocks, deliberately decoupled: the
+                        // freshness baseline (`markedAtMs`) NEVER moves — it is what
+                        // the delivery gate stats against — while the re-arm TTL is
+                        // anchored on `lastRearmedAtMs`, advanced by every successful
+                        // empty probe: the scanner is demonstrably alive, just slow.
+                        if (!isPendingAuxiliaryPastRearmTtl(pair)) {
+                            markPendingAuxiliaryCoverage(lateAuxPath, [pair.serverId], pair.markedAtMs, Date.now());
+                            lateAuxRearmed += 1;
+                        }
+                        continue;
+                    }
+                    const converted = convertLspDiagnostics(rawDiags, lateAuxPath, {
+                        tool: "lsp",
+                    });
+                    if (converted.length === 0)
+                        continue;
+                    // Freshness kernel (#1634 gated surface): stat the cited file
+                    // against the mark timestamp. Missing → drop (no remediation for
+                    // a deleted file); mtime drifted past the mark → drop too, NOT
+                    // demote — unlike the cached-blocker gates these findings were
+                    // NEVER delivered before, and the edit that drifted the file
+                    // already re-touched it (a fresh pending pair supersedes this
+                    // one), so a stale-arm replay would double-report old content.
+                    // Both drops are COUNTED here and in the latency record below —
+                    // never silent (shape 10).
+                    const gate = gateFindingsByPathFreshness({
+                        store: "late-auxiliary-findings",
+                        findings: converted,
+                        cwd,
+                        scannedAt: pair.markedAtMs,
+                        citedPath: () => lateAuxPath,
+                    });
+                    lateAuxStale += gate.stale.length;
+                    lateAuxMissing +=
+                        converted.length - gate.live.length - gate.stale.length;
+                    if (gate.stale.length > 0) {
+                        // Stale findings mean the scan predates the last edit.
+                        // Re-arm with a REFRESHED baseline so the next turn probes
+                        // the newer revision (#2027 round-1 P2-1).
+                        markPendingAuxiliaryCoverage(lateAuxPath, [pair.serverId], Date.now());
+                    }
+                    if (gate.live.length === 0)
+                        continue;
+                    const lines = gate.live.map((f) => `  ${displayLateAuxPath}:${f.line}:${f.column} [${f.rule}] ${f.message}`);
+                    lateAuxDelivered += gate.live.length;
+                    // @delivery-surface: runtime-turn:late-auxiliary-findings
+                    advisoryParts.push(`🕐 Late auxiliary diagnostics (${pair.serverId} answered after its grace window):\n${lines.join("\n")}`);
+                }
+            }
+        }
+        catch (err) {
+            dbg(`turn_end: late-auxiliary probe failed: ${err}`);
+        }
+        logLatency({
+            type: "phase",
+            toolName: "turn_end",
+            filePath: cwd,
+            phase: "late_auxiliary_findings",
+            durationMs: Date.now() - lateAuxStart,
+            metadata: {
+                pending: drainedPairs.length,
+                delivered: lateAuxDelivered,
+                stale: lateAuxStale,
+                missing: lateAuxMissing,
+                rearmed: lateAuxRearmed,
+                clientGone: lateAuxClientGone,
+                probeFailed: lateAuxProbeFailed,
+            },
+        });
+    }
     const labeledAdvisoryParts = advisoryParts.map((p) => `ℹ️ Advisory — no action required this turn:\n${p}`);
     // Stale-secret parts sit between the two tiers and are NOT relabelled — they
     // ship the imperative preamble they were built with (#1622 review M2).

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

@@ -34,9 +34,7 @@ export class RustClient {
     availability;
     log;
     constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("rust")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("rust") : () => { };
         this.availability = createToolchainAvailability({
             tool: "cargo",
             label: "Cargo",

package/node_modules/pi-lens/dist/clients/safe-spawn.js

@@ -37,6 +37,38 @@ export function hasSpawnFailureKind(error, kind) {
         "kind" in error &&
         error.kind === kind);
 }
+/**
+ * #2010: derive teardown evidence from observed timestamps.
+ *
+ * Pure by design so every branch is deterministically unit-testable,
+ * including the natural-exit-at-budget-expiry race where the timeout
+ * callback arms a kill against an already-dead child.
+ *
+ * - No recorded kill start (the guard saw the child already dying), no
+ *   observed death at all, or death PREDATING the kill start: the child
+ *   left on its own -> "exited", ms 0. Claiming a kill we cannot
+ *   distinguish from a natural exit would be invented evidence.
+ * - Death observed after the kill started: "escalate-kill" when the
+ *   SIGKILL escalation fired, otherwise "killed-by-signal"; ms is the
+ *   observed gap (floor 0 - clock jitter must never produce a negative).
+ */
+export function resolveTeardownOutcome(input) {
+    // Another path (abort / output-limit) owns this death: emitting teardown
+    // evidence here would describe a kill this timeout didn't perform.
+    if (input.killStartedAtMs === undefined ||
+        input.deathObservedAtMs === undefined) {
+        return undefined;
+    }
+    // True natural-exit race: the child beat the budget-expired kill by a
+    // hair - death observed before (or exactly at) the kill start.
+    if (input.deathObservedAtMs <= input.killStartedAtMs) {
+        return { ms: 0, outcome: "exited" };
+    }
+    return {
+        ms: Math.max(0, input.deathObservedAtMs - input.killStartedAtMs),
+        outcome: input.escalated ? "escalate-kill" : "killed-by-signal",
+    };
+}
 function toError(error) {
     return error instanceof Error ? error : new Error(String(error));
 }
@@ -74,7 +106,12 @@ function cwdIsUnresolvableSync(cwd) {
  */
 function commandProbablyPresent(command) {
     const exts = process.platform === "win32"
-        ? ["", ...(process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean)]
+        ? [
+            "",
+            ...(process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+                .split(";")
+                .filter(Boolean),
+        ]
         : [""];
     const existsWithExt = (base) => {
         for (const ext of exts) {
@@ -192,7 +229,15 @@ function killPidTreeSync(pid) {
         return;
     }
     try {
-        process.kill(pid, "SIGKILL");
+        // #2026: negative pid = whole process group (POSIX children spawn
+        // detached), reaching grandchildren too. Any failure (ESRCH = already
+        // gone, EPERM = raced) falls through to the direct-child attempt.
+        try {
+            process.kill(-pid, "SIGKILL");
+        }
+        catch {
+            process.kill(pid, "SIGKILL");
+        }
     }
     catch {
         // Child already exited.
@@ -268,10 +313,16 @@ function cmdEscapeArg(arg) {
  * that already worked. The `chcp 65001` prefix forces the UTF-8 code page (so
  * tool output isn't mangled by the system code page) and, as a side benefit,
  * keeps the (possibly quoted) command off the front of the line, avoiding
- * cmd.exe's `/s` outer-quote-stripping quirk.
+ * cmd.exe's `/s` outer-quote-stripping quirk. #2023: chcp is invoked via its
+ * absolute `%SystemRoot%\System32\chcp.com` path and chained with `&`, not
+ * `&&` — a child environment whose PATH cannot resolve System32 used to fail
+ * the bare `chcp` lookup, and `&&` then short-circuited EVERY .cmd/.bat spawn
+ * into exit 1 with empty output. With the pin plus `&`, even a chcp failure
+ * can never suppress the real command.
  */
 export function buildWindowsShellCommand(command, args) {
-    return `chcp 65001 >nul 2>&1 && ${[command, ...args].map(cmdEscapeArg).join(" ")}`;
+    const chcp = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\chcp.com`;
+    return `${chcp} 65001 >nul 2>&1 & ${[command, ...args].map(cmdEscapeArg).join(" ")}`;
 }
 /**
  * The extensions this resolver treats as executable suffixes on their own,
@@ -859,6 +910,15 @@ export async function safeSpawnAsync(command, args, options) {
         // a ref'd 1s timer that outlives the child it was escalating against
         // would keep a one-shot `pi --print` process alive for up to 1s.
         let escalationTimer;
+        let teardownStartedAtMs;
+        let teardownEscalated = false;
+        // #2010: teardown evidence for the spawn's OWN timeout. The wall clock
+        // starts when the budget expires and the tree-kill is issued, and stops
+        // when the process tree is observed dead (`await killPromise` settles)
+        // - measured SEPARATELY from the budget itself, so a slow teardown is
+        // visible instead of silently inflating "how long the tool ran".
+        // `teardownEscalated` names whether SIGTERM sufficed or the SIGKILL
+        // escalation fired (POSIX; Windows taskkill /F is always forceful).
         // #1114: `child.killed` is set by Node the moment `kill()` successfully
         // SENDS a signal, not when the child actually dies — so gating the
         // escalation on `!child.killed` right after a successful `SIGTERM` send
@@ -994,6 +1054,14 @@ export async function safeSpawnAsync(command, args, options) {
             return;
         }
         let child;
+        // #2026: on POSIX, run the child in its OWN process group (detached).
+        // killTree/killPidTreeSync then signal the whole GROUP (-pid), which
+        // makes grandchildren (npm -> node, sh -> sleep, etc.) die with their
+        // tool instead of surviving every timeout as orphans. Detachment stops
+        // direct terminal-signal delivery, so EVERY POSIX pid registers for
+        // lifetime cleanup - pi's signal/exit handlers forward the kill,
+        // preserving die-with-host semantics.
+        const posixProcessGroup = process.platform !== "win32";
         try {
             child = spawn(spawnCmd, spawnArgs, {
                 cwd: spawnCwd,
@@ -1001,6 +1069,7 @@ export async function safeSpawnAsync(command, args, options) {
                 windowsHide: true,
                 shell: false,
                 windowsVerbatimArguments,
+                detached: posixProcessGroup,
             });
         }
         catch (err) {
@@ -1022,7 +1091,10 @@ export async function safeSpawnAsync(command, args, options) {
             }));
             return;
         }
-        if (options?.lifetimeCoupled && child.pid) {
+        if (child.pid && (posixProcessGroup || options?.lifetimeCoupled)) {
+            // #2026: POSIX registers unconditionally - detached children no
+            // longer receive terminal signals directly, so the lifetime
+            // cleanup's signal forwarding IS their die-with-host path.
             installLifetimeCleanup();
             lifetimeState.pids.add(child.pid);
         }
@@ -1066,11 +1138,56 @@ export async function safeSpawnAsync(command, args, options) {
                     child.kill("SIGKILL");
                 }
             }
+            else if (posixProcessGroup && child.pid && child.pid > 0) {
+                // #2026: signal the whole process group. Grandchildren spawned
+                // by the tool share its group, so one signal reaches the whole
+                // tree; a negative-pid ESRCH means it already exited.
+                const pgid = -child.pid;
+                try {
+                    process.kill(pgid, "SIGTERM");
+                }
+                catch {
+                    child.kill("SIGTERM");
+                }
+                // #2027 round-1: gate the SIGKILL escalation on GROUP liveness,
+                // not direct-child death - a tool can exit instantly on SIGTERM
+                // while a SIGTERM-hardy grandchild keeps the group alive. The
+                // timer stays REF'D for group mode (max 1s tail after resolve):
+                // it is the only backstop for this group once finalize deletes
+                // the pid from lifetimeState.
+                escalationTimer = setTimeout(() => {
+                    let groupAlive = true;
+                    try {
+                        process.kill(pgid, 0);
+                    }
+                    catch {
+                        groupAlive = false;
+                    }
+                    if (!groupAlive)
+                        return;
+                    teardownEscalated = true;
+                    logLatency({
+                        type: "phase",
+                        phase: "spawn_group_kill_escalation",
+                        filePath: "",
+                        durationMs: 0,
+                        metadata: { pgid: child.pid },
+                    });
+                    try {
+                        process.kill(pgid, "SIGKILL");
+                    }
+                    catch {
+                        // Raced with group exit.
+                    }
+                }, 1000);
+            }
             else {
                 child.kill("SIGTERM");
                 escalationTimer = setTimeout(() => {
-                    if (!closed)
+                    if (!closed) {
+                        teardownEscalated = true;
                         child.kill("SIGKILL");
+                    }
                 }, 1000);
             }
         };
@@ -1119,14 +1236,21 @@ export async function safeSpawnAsync(command, args, options) {
         // boolean here, before any await, means `waitForPipeIdle` can check
         // "did close already happen" synchronously the moment it runs.
         let closeSeen = false;
+        // #2010: WHEN death was observed - the stop-clock for teardown evidence
+        // and the discriminator for its outcome. A close that predates the
+        // budget-expired kill means the child exited on its own ("exited"), no
+        // matter that the timer callback raced and armed a kill anyway.
+        let closedAtMs;
         child.on("close", () => {
             closeSeen = true;
+            closedAtMs ??= Date.now();
         });
         // Timeout handling - KILL the process, don't just abandon it
         const timeoutId = setTimeout(() => {
             timedOut = true;
             if (!killed && !child.killed) {
                 killed = true;
+                teardownStartedAtMs = Date.now();
                 killPromise = killTree();
             }
         }, timeout);
@@ -1267,11 +1391,14 @@ export async function safeSpawnAsync(command, args, options) {
             await killPromise;
             if (resolved)
                 return;
-            // #1109: the child has exited — if killTree armed the non-Windows
-            // SIGTERM→SIGKILL escalation timer and it hasn't fired yet, clear it
-            // so it doesn't linger as a ref'd handle after this promise resolves.
-            if (escalationTimer)
+            // #1109: the child has exited - clear the non-Windows escalation
+            // timer so it doesn't linger as a ref'd handle. #2027 EXCEPTION:
+            // in POSIX group mode the timer is the liveness-gated SIGKILL
+            // backstop for SIGTERM-hardy grandchildren; it stays armed and
+            // self-cleans within 1s of firing (max 1s ref'd tail).
+            if (escalationTimer && !posixProcessGroup) {
                 clearTimeout(escalationTimer);
+            }
             // #1673 review F1: latch the verdict as DECIDED here, before the
             // idle-pipe wait — not after it. `code`/`signal`/`timedOut`/`aborted`
             // are already fixed by this point (they don't change during the
@@ -1294,6 +1421,15 @@ export async function safeSpawnAsync(command, args, options) {
             const signalInfo = signal ? { signal } : {};
             if (timedOut) {
                 const cause = new Error(`Process timed out after ${timeout}ms (killed with ${signal || "SIGTERM"})`);
+                // #2010: teardown evidence lives ONLY on the timeout path - it
+                // describes how long the tree took to die after the budget
+                // expired, and how it died ("exited" = the child beat the signal;
+                // "killed-by-signal" / "escalate-kill" = how WE ended it).
+                const timeoutTeardown = resolveTeardownOutcome({
+                    killStartedAtMs: teardownStartedAtMs,
+                    deathObservedAtMs: closedAtMs,
+                    escalated: teardownEscalated,
+                });
                 resolve({
                     stdout,
                     stderr,
@@ -1301,6 +1437,7 @@ export async function safeSpawnAsync(command, args, options) {
                     error: cause,
                     failure: "timeout",
                     ...signalInfo,
+                    ...(timeoutTeardown && { timeoutTeardown }),
                     spawnFailure: new SpawnFailureError("timeout", cause.message, cause),
                     ...outputInfo,
                     resourceUsage,
@@ -1383,8 +1520,10 @@ export async function safeSpawnAsync(command, args, options) {
             closed = true;
             clearTimeout(timeoutId);
             abortSignal?.removeEventListener("abort", onAbort);
-            if (escalationTimer)
+            // #2027: group-mode timer stays armed as the grandchild backstop.
+            if (escalationTimer && !posixProcessGroup) {
                 clearTimeout(escalationTimer);
+            }
             if (child.pid)
                 lifetimeState.pids.delete(child.pid);
             const resourceUsage = finishResourceUsage();

package/node_modules/pi-lens/dist/clients/security-scan-client.js

@@ -89,9 +89,7 @@ export class SecurityScanClient {
      */
     constructor(toolName, verbose = false) {
         this.toolName = toolName;
-        this.log = verbose
-            ? createSubsystemLogger(toolName)
-            : () => { };
+        this.log = verbose ? createSubsystemLogger(toolName) : () => { };
     }
     /**
      * Resolve (once) whether the scanner is usable, sharing the probe promise

package/node_modules/pi-lens/dist/clients/session-summary.js

@@ -31,7 +31,9 @@ export function formatSlopScoreSummary(summary) {
     }
     const topRules = summary.ruleCounts.slice(0, 3);
     const detail = topRules.length > 0
-        ? "  (" + topRules.map((entry) => entry.ruleId + " ×" + entry.count).join(", ") + ")"
+        ? "  (" +
+            topRules.map((entry) => entry.ruleId + " ×" + entry.count).join(", ") +
+            ")"
         : "";
     return `Slop score: ${summary.scorePerKloc.toFixed(1)}/KLOC${detail}`;
 }

package/node_modules/pi-lens/dist/clients/sg-runner.js

@@ -151,9 +151,7 @@ export class SgRunner {
      */
     sweepDurablyMissing = [];
     constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("sg-runner")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("sg-runner") : () => { };
     }
     /**
      * Check if ast-grep CLI is available, auto-install if not.

package/node_modules/pi-lens/dist/clients/source-filter.js

@@ -72,9 +72,9 @@ export function sourceTwinCandidates(filePath) {
         : ext === ".cjs"
             ? [".cts", ".ts", ".tsx", ".mts"]
             : ext === ".jsx"
-                // Deliberately retain the broad fallback: a .jsx next to a .ts
-                // is treated as a build artifact even without a .tsx sibling.
-                ? [".tsx", ".ts", ".mts", ".cts"]
+                ? // Deliberately retain the broad fallback: a .jsx next to a .ts
+                    // is treated as a build artifact even without a .tsx sibling.
+                    [".tsx", ".ts", ".mts", ".cts"]
                 : ext === ".js"
                     ? [".ts", ".tsx", ".mts", ".cts"]
                     : [];
@@ -251,7 +251,7 @@ function classifySkipGeneratedOrArtifact(filePath, options) {
     });
 }
 function shouldSkipGeneratedOrArtifact(filePath, options) {
-    return classifySkipGeneratedOrArtifact(filePath, options).verdict === "generated";
+    return (classifySkipGeneratedOrArtifact(filePath, options).verdict === "generated");
 }
 /**
  * Extract the basename (filename without extension) from a path.
@@ -281,7 +281,8 @@ export function findSourceSibling(filePath, probeCache) {
     const dir = getDir(filePath);
     const base = getBasename(filePath);
     for (const [sourceExt, shadowedExts] of Object.entries(SOURCE_PRECEDENCE)) {
-        if (!sourceExtsForCompiledExt(sourceExt).length && shadowedExts.includes(ext)) {
+        if (!sourceExtsForCompiledExt(sourceExt).length &&
+            shadowedExts.includes(ext)) {
             const siblingPath = path.join(dir, base + sourceExt);
             if (probeExists(siblingPath, probeCache))
                 return siblingPath;
@@ -296,7 +297,10 @@ export function findSourceSibling(filePath, probeCache) {
  * Omit for the original, uncached behavior.
  */
 function sourceExtsForCompiledExt(sourceExt) {
-    return sourceExt === ".ts" || sourceExt === ".tsx" || sourceExt === ".mts" || sourceExt === ".cts"
+    return sourceExt === ".ts" ||
+        sourceExt === ".tsx" ||
+        sourceExt === ".mts" ||
+        sourceExt === ".cts"
         ? [sourceExt]
         : [];
 }

package/node_modules/pi-lens/dist/clients/source-walker.js

@@ -31,7 +31,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { isExcludedDirName } from "./file-utils.js";
 import { isGeneratedArtifactDirectoryName } from "./generated-artifacts.js";
-import { createDeadline, yieldIfOverBudget, } from "./cooperative-budget.js";
+import { createDeadline, yieldIfOverBudget } from "./cooperative-budget.js";
 /**
  * Read a directory's entries, returning `[]` for a permission-denied or
  * missing directory instead of throwing. Shared by every walker below — a