@herbertgao/pi-extensions 2026.8.5 → 2026.8.6

package/node_modules/pi-lens/dist/clients/extension-log.js

@@ -20,6 +20,7 @@
  * through the host's own render path (`ctx.ui.notify` / a display-only session
  * entry) — never a raw write.
  */
+import { AsyncLocalStorage } from "node:async_hooks";
 import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
@@ -82,6 +83,260 @@ const CONSOLE_METHODS = [
     "dir",
 ];
 let consoleGuardInstalled = false;
+/** The console methods captured before the patch, for an exact restore. */
+const originalConsoleMethods = new Map();
+/** The replacements this module installed, so uninstall never clobbers a later patch. */
+const installedConsoleMethods = new Map();
+/**
+ * The async capture window (#1434).
+ *
+ * The guard must catch pi-lens's own writes without swallowing the host's. pi's
+ * one-shot CLI commands print through `console.log`, so a permanent global
+ * reroute makes `pi list` print nothing in any project whose cwd loads the
+ * extension first. The store answers "is pi-lens executing right now?" and
+ * `AsyncLocalStorage` carries that answer into every promise, timer and
+ * callback created inside the window — so an async handler still captures after
+ * an `await`, while host code outside the window keeps its real sink.
+ *
+ * Built LAZILY (S1b, #1434 review): an active `AsyncLocalStorage` enables an
+ * async_hooks init hook for every promise in the process on Node 22 — the same
+ * hazard `tree-sitter-client.ts`'s `parseCacheMeasurement.disable()` comment
+ * documents — so constructing one at module scope taxes every `await` in the
+ * host even when the kill switch (`PI_LENS_CONSOLE_GUARD=0`) or test mode means
+ * the guard never installs and nothing ever reads the store. Construction is
+ * deferred to the first `runInConsoleCaptureWindow` call, and only happens once
+ * `installConsoleGuard()` has actually installed (never under the kill switch
+ * or test mode, since `consoleGuardInstalled` stays false in both).
+ */
+let consoleCaptureStorage;
+function getConsoleCaptureStorage() {
+    if (!consoleGuardInstalled)
+        return undefined;
+    if (consoleCaptureStorage === undefined) {
+        consoleCaptureStorage = new AsyncLocalStorage();
+    }
+    return consoleCaptureStorage;
+}
+/**
+ * Module evaluation is the one window `AsyncLocalStorage` cannot wrap: the
+ * module graph is evaluated by the loader, not by a pi-lens call. It is
+ * synchronous, so a plain flag is enough (#1333's original concern — a
+ * transitively loaded dependency writing during its own init).
+ */
+let moduleLoadWindowOpen = false;
+/**
+ * True while pi-lens owns execution, so console writes belong in the log.
+ *
+ * `consoleCaptureStorage` may not have been constructed yet (S1b) — that state
+ * means "no window was ever opened through `runInConsoleCaptureWindow`", i.e.
+ * the same as an empty store, so it reads as "no window" rather than throwing.
+ */
+export function isConsoleCaptureActive() {
+    return (moduleLoadWindowOpen || consoleCaptureStorage?.getStore() === true);
+}
+/**
+ * Open the module-evaluation window. Called by `clients/console-guard-install.ts`
+ * before any other pi-lens module evaluates.
+ *
+ * The window closes explicitly at the end of `index.ts`. The backstop below
+ * closes it anyway if that never runs (an import throws, or the entry changes
+ * shape), because a leaked window would capture the host's output — the very
+ * bug this design fixes. Module evaluation is synchronous, so the end of the
+ * current macrotask is always past it. The timer is unref'd, so it can never
+ * hold a one-shot CLI process open (defect shape 4).
+ */
+export function openModuleLoadConsoleWindow() {
+    if (moduleLoadWindowOpen)
+        return;
+    moduleLoadWindowOpen = true;
+    const backstop = setImmediate(() => {
+        moduleLoadWindowOpen = false;
+    });
+    backstop.unref?.();
+}
+/** Close the module-evaluation window. Idempotent. */
+export function closeModuleLoadConsoleWindow() {
+    moduleLoadWindowOpen = false;
+}
+/**
+ * Run `fn` inside a capture window. Console writes from `fn`, and from anything
+ * `fn` schedules, go to the extension log instead of the terminal.
+ *
+ * When the guard was never installed (kill switch or test mode), there is
+ * nothing for a window to gate — `installConsoleGuard`'s own dispatcher is the
+ * only reader of `isConsoleCaptureActive()`, and it short-circuits before that
+ * call in both cases. Skip constructing the `AsyncLocalStorage` (S1b) and run
+ * `fn` directly.
+ */
+export function runInConsoleCaptureWindow(fn) {
+    const storage = getConsoleCaptureStorage();
+    if (!storage)
+        return fn();
+    return storage.run(true, fn);
+}
+function inCaptureWindow(fn) {
+    return function (...args) {
+        return runInConsoleCaptureWindow(() => fn.apply(this, args));
+    };
+}
+/**
+ * True for every host API member that can hand pi-lens's own functions back to
+ * the host to be called later: `on(event, handler)` and any `register*`
+ * method (`registerTool`, `registerCommand`, `registerMessageRenderer`,
+ * `registerShortcut`, `registerFlag`, `registerMarkdownTransformer`,
+ * `registerEntryRenderer`, `registerProvider`, and any the host adds later).
+ *
+ * This is a DENY-LIST, not an allow-list (#1434 S1a review): every member
+ * matching this predicate gets its function arguments wrapped, with no
+ * per-method exemption. The earlier allow-list form (only `on` and
+ * `registerTool`) let the 9 `registerCommand` call sites and
+ * `registerMessageRenderer` bypass the window, regressing #1333 for those
+ * paths — a host callback fired for one of them would still write straight to
+ * the terminal.
+ */
+function isCaptureSeam(prop) {
+    return prop === "on" || (typeof prop === "string" && prop.startsWith("register"));
+}
+/**
+ * Wrap every function value found in `value`, in place. Handles the two
+ * shapes a `register*`/`on` call takes today: a function passed directly
+ * (`on(event, handler)`, `registerMessageRenderer(type, fn)`), and a
+ * function ONE level inside a plain options/definition object
+ * (`options.handler`, `tool.execute`).
+ *
+ * Deliberately NOT recursive past that one level (#1434 perf review): a tool
+ * definition's `parameters`/`schema` is a large, deeply nested TypeBox object
+ * that holds no functions, but walking its full tree on every `registerTool`
+ * call — across every tool, on every extension activation, across the many
+ * test files that re-activate the extension per case — measurably slowed
+ * activation (a wiring test tripped its 5s budget under transform load; see
+ * the commit body for the measured before/after). Checking only the
+ * argument's own top-level keys is O(keys), independent of how deep an
+ * unrelated nested value's own structure goes, and covers every shape
+ * PI-LENS actually registers (`options.handler`, `tool.execute` — never two
+ * levels deep). It does NOT cover every shape the host's `ExtensionAPI` type
+ * permits: `registerProvider`'s `config.oauth.*` callbacks sit two levels
+ * deep and `config.models[]` sits behind a skipped array. pi-lens never
+ * calls `registerProvider`; extend the descent if that changes (same known-
+ * gap convention as the `pi.events` note in AGENTS.md).
+ *
+ * Mutates the object in place rather than copying — a spread copy would drop
+ * non-enumerable or prototype-carried members of a definition object (defect
+ * shape 5), and these definitions are pi-lens's own, built just above the
+ * register call.
+ */
+function wrapFunctionsInPlace(value) {
+    if (typeof value === "function") {
+        return inCaptureWindow(value);
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return value;
+    }
+    const obj = value;
+    for (const key of Object.keys(obj)) {
+        const propValue = obj[key];
+        if (typeof propValue === "function") {
+            assignWrapped(obj, key, propValue);
+        }
+    }
+    return value;
+}
+/**
+ * Assign a wrapped function back onto `obj[key]`, degrading instead of
+ * throwing or dropping the registration when the property resists (S2b).
+ * ESM is always strict mode, so assigning into a non-writable data property
+ * throws a `TypeError`; `Object.defineProperty` is tried next (it can
+ * redefine a configurable-but-non-writable property); if both fail the
+ * property is frozen solid, so the ORIGINAL unwrapped function is left in
+ * place — the registration still succeeds, just without the console-capture
+ * net for that one callback, which is strictly better than the tool/command
+ * never registering at all.
+ */
+function assignWrapped(obj, key, fn) {
+    const wrapped = inCaptureWindow(fn);
+    try {
+        obj[key] = wrapped;
+        return;
+    }
+    catch {
+        // Non-writable data property — fall through to defineProperty.
+    }
+    try {
+        Object.defineProperty(obj, key, {
+            value: wrapped,
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+    }
+    catch {
+        // Frozen solid: leave the original unwrapped function in place rather
+        // than throwing (which would abort the whole register call) or silently
+        // dropping it.
+    }
+}
+/**
+ * Wrap the host extension API so every pi-lens entry point runs in a capture
+ * window.
+ *
+ * pi calls our event handlers and tool bodies from its own async context, so a
+ * window opened during registration does not reach them. Wrapping every
+ * `register*`/`on` seam (see `isCaptureSeam`) covers every current and future
+ * handler from one place, instead of a hand-maintained list of call sites.
+ * Everything else forwards untouched, except it is bound to `target` (S3a) so
+ * a destructured reference (`const { getFlag } = pi`) keeps working, and
+ * wrapper functions are memoized per-proxy in `wrapperCache` (S3b) so
+ * `proxy.on === proxy.on` — code that compares handler identity, or a test
+ * asserting a mock was called with a specific function reference across two
+ * reads of the same property, sees a stable value.
+ */
+export function withConsoleCaptureWindows(api) {
+    const wrapperCache = new Map();
+    const proxy = new Proxy(api, {
+        get(target, prop) {
+            // A non-configurable, non-writable OWN data property is a proxy
+            // invariant: the get trap MUST return the exact value the target
+            // holds, or the engine throws a TypeError on read. Degrade to the raw
+            // value instead of tripping that invariant (S2a) — a frozen host API
+            // loses the capture window for that member, but keeps working.
+            const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+            if (descriptor && descriptor.writable === false && descriptor.configurable === false) {
+                return descriptor.value;
+            }
+            const cached = wrapperCache.get(prop);
+            if (cached !== undefined)
+                return cached;
+            const value = Reflect.get(target, prop, target);
+            if (typeof value !== "function")
+                return value;
+            const method = value;
+            // A host that returns `this` for chaining would hand back the raw API,
+            // so a chained `on(...).on(...)` would register an unwrapped handler.
+            // Keep the proxy on the chain.
+            const keepProxy = (result) => result === target ? proxy : result;
+            // Pass-through members are cached too (S3a/S3b: `proxy.getFlag ===
+            // proxy.getFlag`), but the cached wrapper re-reads `target[prop]` on
+            // EVERY call rather than closing over `method` -- a plain
+            // `method.bind(target)` pins the function reference captured at first
+            // access, so a host (or a test simulating one) that reassigns its own
+            // method after registration would silently keep calling the stale one.
+            // Re-reading keeps the cached wrapper's identity stable while staying
+            // live to whatever `target[prop]` currently is.
+            const wrapper = isCaptureSeam(prop)
+                ? (...args) => {
+                    const wrapped = args.map((arg) => wrapFunctionsInPlace(arg));
+                    return keepProxy(method.apply(target, wrapped));
+                }
+                : (...args) => {
+                    const current = Reflect.get(target, prop, target);
+                    return current.apply(target, args);
+                };
+            wrapperCache.set(prop, wrapper);
+            return wrapper;
+        },
+    });
+    return proxy;
+}
 function formatConsoleArgs(args) {
     return args
         .map((arg) => {
@@ -104,6 +359,12 @@ function formatConsoleArgs(args) {
  * mirror of `mcp/server.ts`'s `console.log = console.error` guard, which
  * protects the JSON-RPC stdout channel for the same structural reason.
  *
+ * The patch is a DISPATCHER, not a permanent reroute (#1434). It sends a write
+ * to the extension log only while pi-lens owns execution; every other write
+ * goes to the original console method. pi's own one-shot CLI commands print
+ * through `console.log`, so an unconditional reroute silenced them: `pi list`
+ * exited 0 with no output in any project whose cwd loaded the extension first.
+ *
  * This is a NET, not the fix: pi-lens's own sites are migrated to real sinks
  * with real schemas. Idempotent, and inert under test mode (vitest owns the
  * console) and under `PI_LENS_CONSOLE_GUARD=0`.
@@ -120,9 +381,16 @@ export function installConsoleGuard() {
     consoleGuardInstalled = true;
     const target = console;
     for (const method of CONSOLE_METHODS) {
-        if (typeof target[method] !== "function")
+        const original = target[method];
+        if (typeof original !== "function")
             continue;
-        target[method] = (...args) => {
+        const originalFn = original;
+        originalConsoleMethods.set(method, originalFn);
+        const replacement = (...args) => {
+            if (!isConsoleCaptureActive()) {
+                originalFn.apply(console, args);
+                return;
+            }
             logExtension({
                 subsystem: "console",
                 level: method === "warn" ? "warn" : method === "error" ? "error" : "debug",
@@ -130,10 +398,35 @@ export function installConsoleGuard() {
                 metadata: { method },
             });
         };
+        installedConsoleMethods.set(method, replacement);
+        target[method] = replacement;
+    }
+    return true;
+}
+/**
+ * Restore the exact console methods captured at install time.
+ *
+ * A method someone else patched after us is left alone — restoring it would
+ * clobber their replacement. Returns true when this call uninstalled.
+ */
+export function uninstallConsoleGuard() {
+    if (!consoleGuardInstalled)
+        return false;
+    consoleGuardInstalled = false;
+    const target = console;
+    for (const [method, original] of originalConsoleMethods) {
+        if (target[method] === installedConsoleMethods.get(method)) {
+            target[method] = original;
+        }
     }
+    originalConsoleMethods.clear();
+    installedConsoleMethods.clear();
     return true;
 }
-/** Test-only: forget that the guard was installed. */
+/** Test-only: uninstall the guard and close every open capture window. */
 export function _resetConsoleGuardForTests() {
+    uninstallConsoleGuard();
     consoleGuardInstalled = false;
+    consoleCaptureStorage = undefined;
+    moduleLoadWindowOpen = false;
 }

package/node_modules/pi-lens/dist/clients/fix-worklog.js

@@ -18,13 +18,15 @@ export function getWorklogPath(cwd) {
  * diagnostics that were already fixed by the tool, `false` for
  * diagnostics that are fixable but require agent action.
  */
-export function appendToWorklog(cwd, diagnostics, autoFixed) {
+export function appendToWorklog(cwd, diagnostics, autoFixed, identity) {
     if (diagnostics.length === 0)
         return;
     const worklogPath = getWorklogPath(cwd);
     try {
         fs.mkdirSync(path.dirname(worklogPath), { recursive: true });
         const timestamp = new Date().toISOString();
+        const model = identity?.model?.trim() || undefined;
+        const provider = identity?.provider?.trim() || undefined;
         const lines = diagnostics
             .map((d) => {
             const entry = {
@@ -38,6 +40,8 @@ export function appendToWorklog(cwd, diagnostics, autoFixed) {
                 fixable: d.fixable ?? false,
                 fixSuggestion: d.fixSuggestion,
                 autoFixed,
+                model,
+                provider,
             };
             return JSON.stringify(entry);
         })

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

@@ -59,7 +59,15 @@
  * New optional fields may be added under the same `v: 1` for any of the three
  * events; a breaking change to an existing field's meaning must bump that
  * event's `v` independently (each event versions separately since they're
- * unrelated payloads).
+ * unrelated payloads). `FormatQueuedPayload.kinds` (S3d, #1432 review) is now
+ * an always-present required field at `publishFormatQueued`'s call boundary —
+ * both in-repo callers already passed it, so the `?? ["format"]` fallback
+ * was fabricating data no caller asked for. This is NOT a `v` bump: `kinds`
+ * was already part of the v1 payload shape and every wire-format consumer
+ * still reads the same field; a v1 emitter built against an older copy of
+ * this module that omits `kinds` at the call site now fails to compile
+ * rather than silently emitting a guessed value, and any reader written
+ * against v1 that still treats `kinds` as possibly-absent remains correct.
  *
  * Fire-and-forget: publishing must never affect the write path's or
  * `agent_end`'s success or latency. Any failure (bus unavailable, emit
@@ -70,7 +78,7 @@
 import { logBusEvent } from "./bus-events-logger.js";
 import { isBusPublishEnabled } from "./bus-publish.js";
 import { normalizeFilePath } from "./path-utils.js";
-import { createLiveBusEmitter, recordStaleBusFailure, } from "./live-bus-emitter.js";
+import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter, } from "./live-bus-emitter.js";
 export const BUS_FORMAT_QUEUED_EVENT = "pilens:format:queued";
 export const BUS_FORMAT_QUEUED_VERSION = 1;
 export const BUS_FORMAT_START_EVENT = "pilens:format:start";
@@ -131,8 +139,13 @@ export function publishFormatQueued(args) {
         }
         return;
     }
-    const busEmit = liveEmitter.get();
-    if (!busEmit) {
+    const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+        event: BUS_FORMAT_QUEUED_EVENT,
+        cwd: normalizeFilePath(args.cwd),
+    }));
+    if (resolution.outcome === "stale-session")
+        return;
+    if (resolution.outcome === "unwired") {
         if (!hasLoggedQueuedUnwired) {
             hasLoggedQueuedUnwired = true;
             logBusEvent({
@@ -143,6 +156,7 @@ export function publishFormatQueued(args) {
         }
         return;
     }
+    const busEmit = resolution.emit;
     try {
         const payload = {
             v: BUS_FORMAT_QUEUED_VERSION,
@@ -150,6 +164,7 @@ export function publishFormatQueued(args) {
             filePath: normalizeFilePath(args.filePath),
             cwd: normalizeFilePath(args.cwd),
             tool: args.tool,
+            kinds: args.kinds,
         };
         busEmit(BUS_FORMAT_QUEUED_EVENT, payload);
         hasLoggedQueuedFailure = false;
@@ -166,6 +181,7 @@ export function publishFormatQueued(args) {
             outcome: "emit_failed",
             cwd: normalizeFilePath(args.cwd),
             error: String(err),
+            ctxSource: resolution.ctxSource,
         });
         if (!hasLoggedQueuedFailure) {
             hasLoggedQueuedFailure = true;
@@ -196,8 +212,13 @@ export function publishFormatStart(args) {
         }
         return;
     }
-    const busEmit = liveEmitter.get();
-    if (!busEmit) {
+    const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+        event: BUS_FORMAT_START_EVENT,
+        cwd: normalizeFilePath(args.cwd),
+    }));
+    if (resolution.outcome === "stale-session")
+        return;
+    if (resolution.outcome === "unwired") {
         if (!hasLoggedStartUnwired) {
             hasLoggedStartUnwired = true;
             logBusEvent({
@@ -208,6 +229,7 @@ export function publishFormatStart(args) {
         }
         return;
     }
+    const busEmit = resolution.emit;
     try {
         const paths = args.paths.map((p) => normalizeFilePath(p));
         const payload = {
@@ -216,6 +238,7 @@ export function publishFormatStart(args) {
             cwd: normalizeFilePath(args.cwd),
             paths,
             fileCount: paths.length,
+            kinds: args.kinds ?? ["format"],
         };
         busEmit(BUS_FORMAT_START_EVENT, payload);
         hasLoggedStartFailure = false;
@@ -232,6 +255,7 @@ export function publishFormatStart(args) {
             outcome: "emit_failed",
             cwd: normalizeFilePath(args.cwd),
             error: String(err),
+            ctxSource: resolution.ctxSource,
         });
         if (!hasLoggedStartFailure) {
             hasLoggedStartFailure = true;
@@ -265,8 +289,13 @@ export function publishAutofixStart(args) {
         }
         return;
     }
-    const busEmit = liveEmitter.get();
-    if (!busEmit) {
+    const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+        event: BUS_AUTOFIX_START_EVENT,
+        cwd: normalizeFilePath(args.cwd),
+    }));
+    if (resolution.outcome === "stale-session")
+        return;
+    if (resolution.outcome === "unwired") {
         if (!hasLoggedAutofixStartUnwired) {
             hasLoggedAutofixStartUnwired = true;
             logBusEvent({
@@ -277,6 +306,7 @@ export function publishAutofixStart(args) {
         }
         return;
     }
+    const busEmit = resolution.emit;
     try {
         const paths = args.paths.map((p) => normalizeFilePath(p));
         const payload = {
@@ -302,6 +332,7 @@ export function publishAutofixStart(args) {
             outcome: "emit_failed",
             cwd: normalizeFilePath(args.cwd),
             error: String(err),
+            ctxSource: resolution.ctxSource,
         });
         if (!hasLoggedAutofixStartFailure) {
             hasLoggedAutofixStartFailure = true;

package/node_modules/pi-lens/dist/clients/git-guard.js

@@ -1,24 +1,17 @@
-import { createHash } from "node:crypto";
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
 import { isPathIgnoredByProject } from "./file-utils.js";
 import { tokenizeShellCommand } from "./bash-file-access.js";
-import { normalizeMapKey } from "./path-utils.js";
 import { logLatency } from "./latency-logger.js";
-const MAX_AFFECTED_FILES = 256;
+import { advisoryFileHash, advisoryPathKey, MAX_ADVISORY_AFFECTED_FILES, snapshotAdvisoryProvenance, } from "./advisory-provenance.js";
 function resolveGuardPath(filePath, cwd) {
     return path.resolve(cwd, filePath);
 }
 function guardPathKey(filePath, cwd) {
-    return normalizeMapKey(resolveGuardPath(filePath, cwd));
+    return advisoryPathKey(filePath, cwd);
 }
 function fileFingerprint(filePath) {
-    try {
-        return createHash("sha256").update(nodeFs.readFileSync(filePath)).digest("hex");
-    }
-    catch (err) {
-        return `unreadable:${err.code ?? "unknown"}`;
-    }
+    return advisoryFileHash(filePath);
 }
 function currentFileFingerprint(filePath) {
     try {
@@ -31,19 +24,11 @@ function currentFileFingerprint(filePath) {
             : `unreadable:${err.code ?? "unknown"}`;
     }
 }
-function snapshotFileHashes(files, cwd) {
-    const hashes = {};
-    for (const file of files) {
-        const resolved = resolveGuardPath(file, cwd);
-        hashes[guardPathKey(resolved, cwd)] = currentFileFingerprint(resolved);
-    }
-    return hashes;
-}
 function capAffectedFiles(files, cwd) {
     const unique = [...new Set(files.map((file) => resolveGuardPath(file, cwd)))];
     return {
-        files: unique.slice(0, MAX_AFFECTED_FILES),
-        truncated: unique.length > MAX_AFFECTED_FILES,
+        files: unique.slice(0, MAX_ADVISORY_AFFECTED_FILES),
+        truncated: unique.length > MAX_ADVISORY_AFFECTED_FILES,
     };
 }
 /** Recovery is safe only when blocker content and its file provenance agree. */
@@ -424,6 +409,17 @@ export function writeGitGuardRecord(cacheManager, runtime, cwd, record) {
             fileSeqByPath[key] = runtime.getFileSeq(resolveGuardPath(file, cwd));
         }
     }
+    const currentProvenance = snapshotAdvisoryProvenance({
+        cwd,
+        runtime,
+        generation: 0,
+        files: capped.files.map((file) => ({ path: file, role: "affected" })),
+        truncated: capped.truncated,
+    });
+    const fileContentHashes = Object.fromEntries(currentProvenance.files.map((file) => [
+        guardPathKey(file.path, cwd),
+        file.sha256,
+    ]));
     const data = {
         ...record,
         affectedFiles: capped.files,
@@ -432,7 +428,8 @@ export function writeGitGuardRecord(cacheManager, runtime, cwd, record) {
         blockingFiles: Array.isArray(record.blockingFiles)
             ? capAffectedFiles(record.blockingFiles, cwd).files
             : undefined,
-        fileContentHashes: snapshotFileHashes(capped.files, cwd),
+        fileContentHashes,
+        provenance: record.provenance ?? currentProvenance,
     };
     try {
         cacheManager.writeCache("turn-end-findings", data, cwd);

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

@@ -7,15 +7,16 @@
  * Docs: https://pkg.go.dev/golang.org/x/tools/gopls
  */
 import { createSubsystemLogger } from "./extension-log.js";
-import * as fs from "node:fs";
 import * as path from "node:path";
-import { safeSpawnAsync } from "./safe-spawn.js";
+import { createToolchainAvailability, } from "./dispatch/runners/utils/toolchain-availability.js";
 // --- Common install paths ---
 const GO_WINDOWS_PATHS = [
     "C:\\Program Files\\Go\\bin\\go.exe",
     "C:\\Go\\bin\\go.exe",
     "go.exe", // PATH
 ];
+/** Budget for the PATH candidate's `go version` probe, ms. */
+const PROBE_TIMEOUT_MS = 3_000;
 const GO_UNIX_PATHS = [
     "/usr/local/go/bin/go",
     "/usr/bin/go",
@@ -23,58 +24,39 @@ const GO_UNIX_PATHS = [
 ];
 // --- Client ---
 export class GoClient {
-    goAvailable = null;
-    goPath = null;
+    /**
+     * Availability lifecycle, behind the shared transient-aware latch (#1476).
+     * The PATH candidate is resolved by spawning `go version` with a 3 s budget,
+     * so a host stall could latch "no Go toolchain" for the whole session and
+     * silently disable every Go diagnostic until restart.
+     */
+    availability;
     log;
     constructor(verbose = false) {
         this.log = verbose
             ? createSubsystemLogger("go")
             : () => { };
+        this.availability = createToolchainAvailability({
+            tool: "go",
+            label: "Go",
+            windowsPaths: GO_WINDOWS_PATHS,
+            unixPaths: GO_UNIX_PATHS,
+            probeArgs: ["version"],
+            budgetMs: PROBE_TIMEOUT_MS,
+            log: (msg) => this.log(msg),
+        });
     }
     /**
      * Find go executable path (async — probes PATH candidates off the event loop).
      */
     async findGoPathAsync() {
-        if (this.goPath)
-            return this.goPath;
-        const paths = process.platform === "win32" ? GO_WINDOWS_PATHS : GO_UNIX_PATHS;
-        for (const p of paths) {
-            try {
-                if (p.includes("\\") || p.includes("/")) {
-                    // Absolute path - check if exists
-                    if (fs.existsSync(p)) {
-                        this.goPath = p;
-                        return p;
-                    }
-                }
-                else {
-                    // Relative (PATH) - try running it
-                    const result = await safeSpawnAsync(p, ["version"], {
-                        timeout: 3000,
-                    });
-                    if (!result.error && result.status === 0) {
-                        this.goPath = p;
-                        return p;
-                    }
-                }
-            }
-            catch (err) {
-                void err;
-            }
-        }
-        return null;
+        return this.availability.findPath();
     }
     /**
      * Check if Go is installed (cached)
      */
     async isGoAvailableAsync() {
-        if (this.goAvailable !== null)
-            return this.goAvailable;
-        this.goAvailable = (await this.findGoPathAsync()) !== null;
-        if (this.goAvailable) {
-            this.log(`Go found: ${this.goPath}`);
-        }
-        return this.goAvailable;
+        return this.availability.isAvailable();
     }
     /**
      * Check if a file is a Go file