@herbertgao/pi-extensions 2026.8.5 → 2026.8.6

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

@@ -22,11 +22,14 @@ import * as path from "node:path";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import { assertInstallAllowed } from "./project-trust.js";
 import { SecurityScanClient } from "./security-scan-client.js";
+import { classifyProbeFailure, logAvailabilityDecision, startHostStallSampler, } from "./dispatch/runners/utils/availability-policy.js";
 const EMPTY_RESULT = {
     success: false,
     findings: [],
 };
 const SCAN_TIMEOUT_MS = 120_000;
+/** Budget for the `go install` auto-install, ms. */
+const INSTALL_TIMEOUT_MS = 60_000;
 // --- Client ---
 export class GovulncheckClient extends SecurityScanClient {
     constructor(verbose = false) {
@@ -54,6 +57,15 @@ export class GovulncheckClient extends SecurityScanClient {
             this.available = true;
             return true;
         }
+        if (this.probeWasTransient()) {
+            // #1467: a timed-out/killed probe says nothing about whether
+            // govulncheck is on PATH. Latching `false` here disabled it for the
+            // life of the process; a `go install` here would be a heavyweight
+            // reaction to a host hiccup. Record an expiring verdict, retry later.
+            this.log("govulncheck probe timed out; retrying later (not installing)");
+            this.markTransientlyUnavailable(this.lastProbeCause ?? "probe-timeout");
+            return false;
+        }
         if (!assertInstallAllowed("govulncheck go install")) {
             // Deliberately NOT latching `available = false` (#1350 delta review):
             // trust denial is policy, not tool absence -- a later trust grant
@@ -67,27 +79,100 @@ export class GovulncheckClient extends SecurityScanClient {
         // project has a go.mod the user has the Go toolchain by definition.
         // Same shape as rust-clippy / cargo: lean on the language's own
         // install mechanism rather than adding a new installer strategy.
-        const goOnPath = await safeSpawnAsync("go", ["version"], {
-            timeout: 5000,
-        });
+        const goProbeStartedAt = Date.now();
+        const goSampler = startHostStallSampler();
+        let goOnPath;
+        let goHostStallMs;
+        try {
+            goOnPath = await safeSpawnAsync("go", ["version"], {
+                timeout: 5000,
+            });
+        }
+        finally {
+            goHostStallMs = goSampler.stop();
+        }
         if (goOnPath.error || goOnPath.status !== 0) {
+            const { outcome, cause } = classifyProbeFailure(goOnPath, {
+                hostStallMs: goHostStallMs,
+            });
+            if (outcome === "transient") {
+                this.log("`go version` probe timed out; retrying govulncheck later");
+                const retryAfterMs = this.markTransientlyUnavailable(cause);
+                logAvailabilityDecision({
+                    tool: "govulncheck",
+                    verdict: "unavailable",
+                    outcome,
+                    cause,
+                    elapsedMs: Date.now() - goProbeStartedAt,
+                    latched: false,
+                    hostStallMs: goHostStallMs,
+                    ...(retryAfterMs > 0 && { retryAfterMs }),
+                    budgetMs: 5000,
+                });
+                return false;
+            }
             this.log("go binary not on PATH — cannot auto-install govulncheck");
             this.available = false;
             return false;
         }
         this.log("govulncheck not found, attempting auto-install via go install");
-        const install = await safeSpawnAsync("go", ["install", "golang.org/x/vuln/cmd/govulncheck@latest"], { timeout: 60_000 });
+        const installStartedAt = Date.now();
+        const installSampler = startHostStallSampler();
+        let install;
+        let installHostStallMs;
+        try {
+            install = await safeSpawnAsync("go", ["install", "golang.org/x/vuln/cmd/govulncheck@latest"], { timeout: INSTALL_TIMEOUT_MS });
+        }
+        finally {
+            installHostStallMs = installSampler.stop();
+        }
         if (install.error || install.status !== 0) {
             this.log(`govulncheck auto-install failed: ${(install.stderr ?? "").slice(0, 200)}`);
+            // #1476: `go install` runs against a 60 s budget over the network. A
+            // timed-out or killed install says nothing about whether govulncheck
+            // can ever be installed here, so it must not latch the durable
+            // "tool is not installed" verdict the way a real install refusal does.
+            // A non-zero exit (module not found, compile error) still latches:
+            // that IS evidence about this machine, and retrying it every turn
+            // would be a `go install` storm.
+            const { outcome, cause } = classifyProbeFailure(install, {
+                hostStallMs: installHostStallMs,
+            });
+            if (outcome === "transient") {
+                const retryAfterMs = this.markTransientlyUnavailable(cause);
+                // One record per decision, so an install that keeps timing out is
+                // readable in latency.log the same day (#1467's forensic trail).
+                logAvailabilityDecision({
+                    tool: "govulncheck",
+                    verdict: "unavailable",
+                    outcome,
+                    cause,
+                    elapsedMs: Date.now() - installStartedAt,
+                    latched: false,
+                    hostStallMs: installHostStallMs,
+                    ...(retryAfterMs > 0 && { retryAfterMs }),
+                    budgetMs: INSTALL_TIMEOUT_MS,
+                });
+                return false;
+            }
             this.available = false;
             return false;
         }
         // `go install` writes to `$GOBIN` or `$GOPATH/bin`. The user may not
         // have that on `$PATH`. Re-probe by name (works when it is on PATH)
         // then fall back to the canonical bin dirs.
-        const reprobe = await safeSpawnAsync("govulncheck", ["-version"], {
-            timeout: 5000,
-        });
+        const reprobeStartedAt = Date.now();
+        const reprobeSampler = startHostStallSampler();
+        let reprobe;
+        let reprobeHostStallMs;
+        try {
+            reprobe = await safeSpawnAsync("govulncheck", ["-version"], {
+                timeout: 5000,
+            });
+        }
+        finally {
+            reprobeHostStallMs = reprobeSampler.stop();
+        }
         if (!reprobe.error && reprobe.status === 0) {
             this.log("govulncheck auto-installed and found on PATH");
             this.available = true;
@@ -118,6 +203,30 @@ export class GovulncheckClient extends SecurityScanClient {
                 // fall through to next candidate
             }
         }
+        // The install SUCCEEDED, so the tool is on this machine somewhere. If the
+        // re-probe merely timed out, latching "not installed" would be the #1467
+        // mistake one step later in the same function (#1476).
+        const { outcome, cause } = classifyProbeFailure(reprobe, {
+            hostStallMs: reprobeHostStallMs,
+        });
+        if (outcome === "transient") {
+            this.log("govulncheck installed but the re-probe timed out; retrying later");
+            const retryAfterMs = this.markTransientlyUnavailable(cause);
+            logAvailabilityDecision({
+                tool: "govulncheck",
+                verdict: "unavailable",
+                outcome,
+                cause,
+                // The re-probe's own wall time. A hard-coded 0 here was the #1474
+                // defect verbatim: a duration field that measures nothing.
+                elapsedMs: Date.now() - reprobeStartedAt,
+                latched: false,
+                hostStallMs: reprobeHostStallMs,
+                ...(retryAfterMs > 0 && { retryAfterMs }),
+                budgetMs: 5000,
+            });
+            return false;
+        }
         this.log("govulncheck auto-install succeeded but binary not locatable — check $GOBIN / $GOPATH");
         this.available = false;
         return false;

package/node_modules/pi-lens/dist/clients/host-ports.js

@@ -15,7 +15,7 @@ export function createDefaultHostPorts(overrides = {}) {
             suppressesUserNotify: () => false,
         },
         log: { extension: () => { }, debug: () => { }, sink: () => () => { } },
-        emit: { bus: () => { }, lens: () => { } },
+        emit: { bus: () => { } },
         status: { set: () => { } },
         spawn: { abortSignal: () => undefined, isAllowed: () => true },
         render: { invalidate: () => { } },

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

@@ -241,7 +241,11 @@ export const TOOLS = [
         checkCommand: "tsc",
         checkArgs: ["--version"],
         installStrategy: "npm",
-        packageName: "typescript",
+        // The managed compiler serves the classic typescript-language-server
+        // fallback. TypeScript 7 removed lib/tsserver.js and is selected only from
+        // project-local installs through the native `tsc --lsp --stdio` path.
+        // Revisit when typescript-language-server supports TS 7 — refs #1436.
+        packageName: "typescript@5.9.3",
         binaryName: "tsc",
     },
     {

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

@@ -12,11 +12,11 @@ import * as fs from "node:fs";
 import { mkdtempSync } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { getExcludedDirGlobs, getGlobalPiLensDir, getProjectIgnoreGlobs, getProjectIgnoreMatcher, } from "./file-utils.js";
+import { getExcludedDirGlobs, getProjectIgnoreGlobs, getProjectIgnoreMatcher, } from "./file-utils.js";
 import { findNodeToolBinary } from "./package-manager.js";
 import { isAtOrAboveHomeDir, isFullyQualified } from "./path-utils.js";
 import { getJscpdMaxEntriesDerived } from "./project-scale.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall } from "./dispatch/runners/utils/runner-helpers.js";
+import { createAvailabilityChecker, findManagedNodeToolBinary, resolveAvailableOrInstall, } from "./dispatch/runners/utils/runner-helpers.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import { shouldRecurseIntoDir, walkTreeStackSync } from "./source-walker.js";
 const EMPTY_RESULT = {
@@ -29,13 +29,8 @@ const EMPTY_RESULT = {
 const SCAN_TIMEOUT_MS = 30_000;
 const jscpdAvailability = createAvailabilityChecker("jscpd", "", ["--version"], {
     probeTimeout: 1500,
-    fastPath: () => {
-        const localBase = path.join(getGlobalPiLensDir(), "tools", "node_modules", ".bin", "jscpd");
-        const candidates = process.platform === "win32"
-            ? [`${localBase}.cmd`, `${localBase}.exe`, localBase]
-            : [localBase];
-        return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
-    },
+    // One definition of the managed-shim fast path, shared with knip (#1476).
+    fastPath: () => findManagedNodeToolBinary("jscpd"),
 });
 // --- Client ---
 export class JscpdClient {

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

@@ -14,7 +14,8 @@ import * as path from "node:path";
 import { getProjectDataDir } from "./file-utils.js";
 import { findNearestMarkerRoot } from "./path-utils.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
-import { createAvailabilityChecker, getManagedToolEnvironment, resolveAvailableOrInstall, } from "./dispatch/runners/utils/runner-helpers.js";
+import { createAvailabilityChecker, findManagedNodeToolBinary, getManagedToolEnvironment, resolveAvailableOrInstall, } from "./dispatch/runners/utils/runner-helpers.js";
+import { createAvailabilityLatch, describeUnavailability, } from "./dispatch/runners/utils/availability-policy.js";
 const EMPTY_RESULT = {
     success: false,
     issues: [],
@@ -61,8 +62,14 @@ export class KnipClient {
     knipAvailability = createAvailabilityChecker("knip", ".cmd", ["--version"], {
         environment: (cwd) => getManagedToolEnvironment("knip", cwd),
         unclassifiedFailureOutcome: "missing",
+        fastPath: () => findManagedNodeToolBinary("knip"),
     });
-    knipAvailable = null;
+    /**
+     * Client-side memo. Only a DURABLE verdict is latched — a transient probe
+     * failure expires, so an installed knip becomes available again without a
+     * host restart (#1467).
+     */
+    availabilityLatch = createAvailabilityLatch();
     knipCommand = "knip";
     ensureInFlight = null;
     log;
@@ -104,12 +111,17 @@ export class KnipClient {
         return findNearestMarkerRoot(startDir, ["package.json", "knip.json", "knip.ts", "knip.config.js", "knip.config.ts"], { boundaries: [".git", ".hg", ".svn"], homeDir: homeDirOverride });
     }
     /**
-     * Check if knip CLI is available, auto-install if not
+     * Check if knip CLI is available, auto-install if not.
+     *
+     * The memo returns `null` when the last verdict was transient and its
+     * cooldown has expired, which re-enters the probe. That is the difference
+     * between "knip is missing" (a fact worth caching) and "the probe timed out"
+     * (a moment worth retrying).
      */
     async ensureAvailable() {
-        // Fast path: already checked
-        if (this.knipAvailable !== null)
-            return this.knipAvailable;
+        const memo = this.availabilityLatch.read();
+        if (memo !== null)
+            return memo;
         if (this.ensureInFlight)
             return this.ensureInFlight;
         this.ensureInFlight = this.doEnsureAvailable();
@@ -121,11 +133,39 @@ export class KnipClient {
         }
     }
     async doEnsureAvailable() {
-        const resolved = await resolveAvailableOrInstall(this.knipAvailability, "knip", process.cwd());
-        this.knipAvailable = resolved !== null;
-        if (resolved)
+        const cwd = process.cwd();
+        const resolved = await resolveAvailableOrInstall(this.knipAvailability, "knip", cwd);
+        if (resolved !== null) {
             this.knipCommand = resolved;
-        return this.knipAvailable;
+            this.availabilityLatch.noteAvailable();
+            return true;
+        }
+        const verdict = this.knipAvailability.getVerdict(cwd);
+        this.availabilityLatch.noteUnavailable(verdict.outcome ?? "missing", verdict.cause ?? "not-found");
+        return false;
+    }
+    /**
+     * The single place a knip-unavailable result is worded. A transient probe
+     * failure must never be reported as "install knip" — knip is on disk.
+     */
+    unavailableResult() {
+        const verdict = this.knipAvailability.getVerdict(process.cwd());
+        const transient = verdict.outcome === "transient";
+        const retryAfterMs = verdict.retryAtMs
+            ? Math.max(0, verdict.retryAtMs - Date.now())
+            : undefined;
+        return {
+            ...EMPTY_RESULT,
+            failureKind: transient ? "unavailable-transient" : "unavailable-missing",
+            summary: describeUnavailability({
+                tool: "Knip",
+                installHint: "npm install -D knip",
+                outcome: verdict.outcome,
+                cause: verdict.cause,
+                elapsedMs: verdict.elapsedMs,
+                retryAfterMs,
+            }),
+        };
     }
     /**
      * Run knip analysis on the project.
@@ -152,10 +192,7 @@ export class KnipClient {
             };
         }
         if (!(await this.ensureAvailable())) {
-            return {
-                ...EMPTY_RESULT,
-                summary: "Knip not available. Install with: npm install -D knip",
-            };
+            return this.unavailableResult();
         }
         const key = path.resolve(targetDir);
         const existing = this.inFlight.get(key);

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

@@ -17,6 +17,55 @@ const writer = createNdjsonLogger({
  * the test-mode guard so it is deterministic and unit-testable.
  */
 let lastPhase;
+/**
+ * Phases excluded from `lastPhase` attribution alongside `loop_block`.
+ * #1412 L3: `lsp_typescript_project_identity` is the classic-TS first-open
+ * project-identity probe (tsserver-sync.ts) — a detached, best-effort
+ * telemetry sample fired on every first didOpen, not genuine work. Letting it
+ * win `lastPhase` would overwrite the real stall attribution for a
+ * loop_block that happens to land right after a first open.
+ * #1432 review: `advisory_provenance_decision`,
+ * `authoritative_content_attachment_decision`, and
+ * `agent_end_deferred_mutation_drain` are the same shape — zero-duration
+ * decision telemetry, not genuine work — so they get the same exclusion.
+ * `agent_end_deferred_mutation_requeue` (S2d gap 4's per-requeue record) and
+ * `session_end_bus_rollup` (S2d gap 5's session-end rollup) are new
+ * zero-duration siblings of the same shape, added alongside them.
+ *
+ * `lsp_aux_wait_outcome` (#1458) is DIFFERENT from every entry above: its
+ * `durationMs` is a REAL bounded wait (the post-primary auxiliary grace, up
+ * to a few seconds), not zero-duration decision telemetry. It is still
+ * excluded because it is a WAIT-OUTCOME RECORD written after the aux wait
+ * already completed, not the stall itself — that wait ran inside the
+ * `lsp_touch_file`/diagnostics phase surrounding it, so letting this summary
+ * row win `lastPhase` would misattribute a `loop_block` to the record instead
+ * of to whatever phase is actually stalled when the block fires.
+ * #1453: `tool_set_mutation` records an active-tool-set rewrite (zero-duration
+ * bookkeeping, and it fires during session_start where a real stall must stay
+ * attributed to the work around it), so it is excluded for the same reason.
+ * #1467: `availability_decision` records a tool-probe verdict. Its `durationMs`
+ * is the child's own probe time (often zero for a fast path or a cached
+ * decision) and the record is bookkeeping ABOUT a probe, not host work — a
+ * loop_block landing next to one must stay attributed to whatever really
+ * stalled the loop, which is frequently the very thing that expired the probe.
+ *
+ * #1461 slice 1: `finding_dead_path_drop` is the same shape — the record a
+ * delivery seam writes when it drops findings whose cited path no longer
+ * exists.
+ */
+const LAST_PHASE_EXCLUDED = new Set([
+    "loop_block",
+    "lsp_typescript_project_identity",
+    "advisory_provenance_decision",
+    "authoritative_content_attachment_decision",
+    "agent_end_deferred_mutation_drain",
+    "agent_end_deferred_mutation_requeue",
+    "session_end_bus_rollup",
+    "lsp_aux_wait_outcome",
+    "tool_set_mutation",
+    "availability_decision",
+    "finding_dead_path_drop",
+]);
 /**
  * The last non-`loop_block` phase logged, or undefined if none yet. Carries its
  * own `ts` so a consumer can gauge staleness: it is intentionally NOT cleared at
@@ -29,7 +78,7 @@ export function getLastLoggedPhase() {
 }
 export function logLatency(entry) {
     const ts = new Date().toISOString();
-    if (entry.type === "phase" && entry.phase && entry.phase !== "loop_block") {
+    if (entry.type === "phase" && entry.phase && !LAST_PHASE_EXCLUDED.has(entry.phase)) {
         lastPhase = { phase: entry.phase, ts };
     }
     if (isTestMode()) {

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

@@ -1,20 +1,17 @@
 import { logExtension } from "./extension-log.js";
+import { logBusEvent } from "./bus-events-logger.js";
+import { normalizeFilePath } from "./path-utils.js";
+import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter, } from "./live-bus-emitter.js";
 export const LENS_EVENT_VERSION = 1;
 export const LENS_EVENT_NAMES = {
     analysisComplete: "pi-lens/analysis-complete",
     findings: "pi-lens/findings",
     turnFindings: "pi-lens/turn-findings",
 };
-let lensEventBus;
-let lensEventBusGetter;
-export function initLensEvents(pi) {
-    lensEventBus = pi.events;
-    lensEventBusGetter = undefined;
-}
+const liveEmitter = createLiveBusEmitter();
 /** Keep deferred deliveries on the live extension activation. */
 export function initLensEventsGetter(getter) {
-    lensEventBusGetter = getter;
-    lensEventBus = undefined;
+    liveEmitter.wireGetter(getter);
 }
 function truncateText(value, maxChars) {
     if (value === undefined)
@@ -38,28 +35,62 @@ function normalizeDiagnostics(diagnostics) {
 // during startup/replacement windows) but must not be invisible. One line per
 // process — enough to notice a permanently-missing bus without spamming.
 let _droppedEmitLogged = false;
+// Emit-failure gating (H1, #1415 review): occurrence-scoped, matching every
+// other producer's `hasLoggedFailure` guard (see clients/bus-publish.ts) and
+// AGENTS.md's "one bus-stale degradation per occurrence" invariant. A success
+// re-arms it, so a later failure records a fresh degradation rather than
+// being silently absorbed by an earlier one.
+let hasLoggedFailure = false;
+/** Test-only: reset module state between test files. */
+export function _resetForTests() {
+    liveEmitter.reset();
+    _droppedEmitLogged = false;
+    hasLoggedFailure = false;
+}
 function emitLensEvent(eventName, payload) {
     setImmediate(() => {
-        try {
-            const bus = lensEventBusGetter?.() ?? lensEventBus;
-            const emit = bus?.emit;
-            if (!emit) {
-                if (!_droppedEmitLogged) {
-                    _droppedEmitLogged = true;
-                    logExtension({
-                        subsystem: "lens-events",
-                        level: "warn",
-                        message: `lens event dropped (no live bus): ${eventName} — further drops logged once per process`,
-                        metadata: { eventName },
-                    });
-                }
-                return;
+        const rawCwd = payload.cwd ?? process.cwd();
+        // M1: normalizeFilePath is a sync realpathSync.native on Windows — 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, () => ({
+            event: eventName,
+            cwd: normalizeFilePath(rawCwd),
+        }));
+        if (resolution.outcome === "stale-session")
+            return;
+        if (resolution.outcome === "unwired") {
+            if (!_droppedEmitLogged) {
+                _droppedEmitLogged = true;
+                logExtension({
+                    subsystem: "lens-events",
+                    level: "warn",
+                    message: `lens event dropped (no live bus): ${eventName} — further drops logged once per process`,
+                    metadata: { eventName },
+                });
             }
-            emit.call(bus, eventName, payload);
+            return;
         }
-        catch {
+        const cwd = normalizeFilePath(rawCwd);
+        try {
+            resolution.emit(eventName, payload);
+            hasLoggedFailure = false;
+            logBusEvent({ event: eventName, outcome: "emitted", cwd });
+        }
+        catch (err) {
+            logBusEvent({
+                event: eventName,
+                outcome: "emit_failed",
+                cwd,
+                error: String(err),
+                ctxSource: resolution.ctxSource,
+            });
+            if (!hasLoggedFailure) {
+                hasLoggedFailure = true;
+                recordStaleBusFailure(eventName, err);
+            }
             // Inter-extension events are observational. A listener must never break
-            // the pi-lens hook path or delay agent progress with error handling noise.
+            // the pi-lens hook path or delay agent progress.
         }
     });
 }

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

@@ -164,6 +164,14 @@ export const LENS_FLAGS = [
         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.",
+        configKey: "tools.lazy",
+        negated: true,
+        default: false,
+        scope: "global",
+    },
 ];
 const byName = new Map(LENS_FLAGS.map((spec) => [spec.name, spec]));
 export function getLensFlagSpec(name) {

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

@@ -1,4 +1,6 @@
 import { recordDegradation } from "./degradation-ledger.js";
+import { probeCtxActive } from "./session-lifecycle.js";
+import { logBusEvent, } from "./bus-events-logger.js";
 const STALE_CTX_MESSAGE = "This extension ctx is stale after session replacement";
 /** Ledger a dead activation once, at the publisher's occurrence-window guard. */
 export function recordStaleBusFailure(subject, error) {
@@ -19,8 +21,26 @@ export function createLiveBusEmitter() {
             getter = next;
             emit = undefined;
         },
-        get() {
-            return getter?.() ?? emit;
+        resolve() {
+            // Invoke the getter for every delivery so session_start rewiring can
+            // replace a captured pre-await activation with the current primary. When
+            // the current target is nevertheless confirmed stale, never invoke it.
+            const target = getter?.() ?? emit;
+            if (!target)
+                return { outcome: "unwired", ctxSource: "unwired" };
+            if (typeof target === "function") {
+                return { outcome: "ready", emit: target, ctxSource: "global-fallback" };
+            }
+            // Object targets are always "own"-sourced (only `wire(fn)`'s bare
+            // function arm is "global-fallback", and it never reaches this
+            // branch) — compute it once so the ready/stale-session outcomes
+            // below both carry the same value instead of restating the
+            // literal independently.
+            const ctxSource = "own";
+            if (probeCtxActive(target.ctx) === false) {
+                return { outcome: "stale-session", ctxSource };
+            }
+            return { outcome: "ready", emit: target.emit, ctxSource };
         },
         reset() {
             emit = undefined;
@@ -28,3 +48,26 @@ export function createLiveBusEmitter() {
         },
     };
 }
+/**
+ * Resolve through the shared stale-session guard and record a declined
+ * target.
+ *
+ * `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
+ * 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.
+ */
+export function resolveLiveBusEmitter(liveEmitter, entry) {
+    const resolution = liveEmitter.resolve();
+    if (resolution.outcome === "stale-session") {
+        logBusEvent({
+            ...entry(),
+            outcome: "skipped_stale_session",
+            level: "info",
+            ctxSource: resolution.ctxSource,
+        });
+    }
+    return resolution;
+}

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

@@ -26,9 +26,12 @@
  *   receive `options.auxGraceMs` before the race finalises. Aux results within
  *   that window are included; later arrivals are dropped. When no descriptors
  *   carry `role:"auxiliary"` the aux-grace path is never entered.
- * @param options.auxGraceMs - Grace period given to auxiliary promises after all
- *   primary promises have settled. Only relevant when at least one descriptor
- *   carries `role:"auxiliary"`. Defaults to 500ms.
+ * @param options.auxGraceMs - Ceiling on the grace period given to auxiliary
+ *   promises after all primary promises have settled. Only relevant when at
+ *   least one descriptor carries `role:"auxiliary"`. Defaults to 500ms. When a
+ *   still-pending auxiliary's descriptor carries `budgetMs`, the actual window
+ *   is `min(auxGraceMs, max(budgetMs of still-pending auxiliaries))` — see
+ *   `PromiseDescriptor.budgetMs`.
  */
 export async function raceToCompletion(promises, shouldComplete, options = { timeoutMs: 1500 }) {
     const results = new Array(promises.length).fill(undefined);
@@ -76,7 +79,30 @@ export async function raceToCompletion(promises, shouldComplete, options = { tim
             if (auxGraceStarted || completed)
                 return;
             auxGraceStarted = true;
-            const graceMs = options.auxGraceMs ?? 500;
+            const ceilingMs = options.auxGraceMs ?? 500;
+            // #1458 S2: cap the grace window by the still-pending auxiliaries' own
+            // declared budgets, not just the flat ceiling — mirrors touchFile's
+            // per-server `min(declared, ceiling)`.
+            //
+            // This is ONE shared timer, not a deadline per promise, so it grants
+            // every pending auxiliary the window of its slowest pending sibling.
+            // That is safe here only because of an invariant the caller upholds,
+            // not because of anything this function enforces: every promise
+            // `getDiagnostics` passes in is already self-bounded by the same
+            // `strategy.aggregateWaitMs` it declares as `budgetMs`, so a fast
+            // auxiliary resolves on its own deadline long before a slow sibling's
+            // window expires. A caller that passes a promise NOT self-bounded by
+            // its descriptor's `budgetMs` — or one that outlives it, the way
+            // `expectSemanticSecondPush` extends a primary — would get a window
+            // wider than it declared. `PromiseDescriptor` is public, so treat that
+            // as a real constraint on new callers rather than a theoretical one.
+            const pendingAuxBudgets = [...auxIndices]
+                .filter((i) => results[i] === undefined)
+                .map((i) => descriptors[i]?.budgetMs)
+                .filter((b) => typeof b === "number" && b >= 0);
+            const graceMs = pendingAuxBudgets.length > 0
+                ? Math.min(ceilingMs, Math.max(...pendingAuxBudgets))
+                : ceilingMs;
             if (graceMs <= 0) {
                 finalize();
                 return;