@herbertgao/pi-extensions 2026.8.6 → 2026.8.8

package/node_modules/pi-lens/dist/clients/dispatch/lazy.js

@@ -1,14 +1,17 @@
 /** Lazy dispatch integration seam for startup-cost control (#1394). */
-let integrationPromise;
+import { createLazyImport } from "../lazy-import.js";
+const lazyIntegration = createLazyImport(() => import("./integration.js"));
 /** Start loading the runner graph once; callers may fire-and-forget this. */
 export function warmDispatchIntegration() {
-    return (integrationPromise ??= import("./integration.js"));
+    return lazyIntegration.get();
 }
 /** Await the same promise used by session-start warming and first use. */
 export function loadDispatchIntegration() {
     return warmDispatchIntegration();
 }
-/** Test-only reset; production sessions intentionally retain the promise. */
+/** Test-only reset; production sessions intentionally retain the promise
+ * across successful loads (a rejection already evicts itself — see
+ * `createLazyImport`). */
 export function resetDispatchIntegrationForTests() {
-    integrationPromise = undefined;
+    lazyIntegration.resetForTests();
 }

package/node_modules/pi-lens/dist/clients/dispatch/plan.js

@@ -221,6 +221,11 @@ export const LANGUAGE_CAPABILITY_MATRIX = {
         capabilities: ["types", "lint"],
         writeGroups: [primary("clojure")],
     },
+    cue: {
+        name: "CUE Linting",
+        capabilities: ["types", "lint"],
+        writeGroups: [primary("cue")],
+    },
     terraform: {
         name: "Terraform Linting",
         capabilities: ["types", "lint", "security"],

package/node_modules/pi-lens/dist/clients/dispatch/runners/ast-grep-napi.js

@@ -15,6 +15,7 @@ import { logLatency } from "../../latency-logger.js";
 import { hasEslintConfig } from "../../tool-policy.js";
 import { enabledAuxiliaryLspServerIds } from "../auxiliary-lsp.js";
 import { classifyDefect } from "../diagnostic-taxonomy.js";
+import { recordDegradationOnce } from "../../degradation-ledger.js";
 import { isAuxiliaryLspAlive } from "../../lsp/index.js";
 import { resolveAstGrepNativeExe } from "../../lsp/wait-policy/index.js";
 import { PRIORITY } from "../priorities.js";
@@ -25,22 +26,179 @@ const UNSUPPORTED_RULE_ID_SAMPLE_SIZE = 5;
 export function resetAstGrepUnsupportedLanguageLog() {
     defaultUnsupportedLanguageLog.clear();
 }
-// Lazy load the napi package
+// Lazy load the napi package.
 let sg;
-let sgLoadAttempted = false;
+/**
+ * In-flight load, shared by every caller (#1567). The per-edit fallback
+ * runner and the session-start scanner (clients/project-diagnostics/scanner.ts)
+ * both call `loadSg()` and can race. Pre-fix, the "attempted" flag was set
+ * before the load and read by the SECOND caller as "already tried" while the
+ * first load was still pending and about to succeed — a false-negative
+ * STARVATION, not a duplicate load: the second caller got back `undefined`
+ * for a load that was in flight and would have succeeded, not a second
+ * redundant `import()`. Sharing one promise means every concurrent caller
+ * observes the SAME outcome instead of a subset of them starving.
+ *
+ * Evicted on settle (#1536's pattern, see clients/tree-sitter-client.ts) — a
+ * rejected load must not be remembered as the permanent answer; only
+ * concurrent callers during the SAME attempt observe this promise.
+ */
+let sgLoadPromise;
+/**
+ * Set on ANY load failure and cleared only by `resetAstGrepNapiLoadState()`
+ * at session_start (#1567 review round 2, F2).
+ *
+ * This holds for BOTH genuine and classified-transient failures, which is
+ * narrower than the original design (a cooldown-then-retry for transient
+ * failures within the same session). The reason: `loadAstGrepNapi()`
+ * (clients/deps/ast-grep-napi.ts) resolves the addon to a `file://` URL and
+ * dynamically `import()`s it. Node's ESM loader permanently memoizes a
+ * module record that threw during evaluation — re-importing the SAME
+ * resolved URL replays the cached rejection, it does not re-run the load.
+ * A cooldown-then-retry loop would therefore call `loadAstGrepNapi()` again
+ * after the cooldown and get back the identical cached rejection every
+ * time: a retry that LOOKS like it tries again but structurally cannot
+ * succeed within the process. Rather than ship that, every failure holds
+ * until the next `session_start`, which is the point this cache can
+ * actually be expected to have moved on (a fresh session re-arms the latch;
+ * whether the underlying Node module cache also gets a fresh start depends
+ * on whether the host recycles the process between sessions, but re-arming
+ * the latch is the most this in-process code can honestly promise).
+ */
+let sgSessionHold = false;
+/**
+ * Why `sgSessionHold` was set — feeds the degradation-ledger message and log
+ * line only. It does not change retry behavior: both classes hold
+ * identically for the session, per `sgSessionHold`'s doc above.
+ */
+let sgHoldReason;
+/** A positively-identified, narrow errno family for a native-addon load: the
+ * kind of momentary FS contention (too many open files, a file mid-write,
+ * a transient permission/resource block) that says nothing durable about
+ * whether the addon itself can load. Everything NOT in this allowlist is
+ * genuine by default (#1567 review round 2, F1) — the original classifier
+ * inverted this: it matched a handful of message patterns as "genuine" and
+ * treated every OTHER error, including the real native-binding failure
+ * family (ABI mismatch, a missing platform package, a napi version
+ * mismatch, an unsupported arch), as transient. None of those recover on
+ * their own; an unrecognized error is far more likely to be one of them
+ * than a genuine FS hiccup. */
+const TRANSIENT_ERRNO_ALLOWLIST = new Set([
+    "EMFILE",
+    "EBUSY",
+    "EAGAIN",
+    "EPERM",
+    "ETXTBSY",
+]);
+/**
+ * `@ast-grep/napi`'s own terminal "this machine cannot run this addon"
+ * messages (from its `index.js` platform-detection shim). Already covered
+ * by the genuine-by-default policy above; listed explicitly so the
+ * classification is legible at the call site instead of an emergent
+ * property of "didn't match the allowlist".
+ */
+const KNOWN_GENUINE_NATIVE_LOAD_MESSAGES = [
+    /cannot find native binding/i,
+    /failed to load native binding/i,
+];
+/**
+ * Walk an error's `.cause` chain — Node/napi wrap the real dlopen/ABI
+ * failure there rather than on the top-level thrown Error — collecting
+ * every `code` and `message` seen along the way, so classification isn't
+ * blind to a nested cause (#1567 review round 2, F1).
+ */
+function collectErrorChain(err) {
+    const codes = [];
+    const messages = [];
+    let current = err;
+    const seen = new Set();
+    while (current !== undefined && current !== null && !seen.has(current)) {
+        seen.add(current);
+        if (current instanceof Error) {
+            messages.push(current.message);
+            const code = current.code;
+            if (typeof code === "string")
+                codes.push(code);
+            current = current.cause;
+        }
+        else {
+            messages.push(String(current));
+            break;
+        }
+    }
+    return { codes, messages };
+}
+/**
+ * Classify a `loadAstGrepNapi()` rejection. Transient requires a positively
+ * identified errno match somewhere in the cause chain AND no known-genuine
+ * native-load message anywhere in that same chain (an errno wrapping a
+ * "cannot find native binding" cause is genuine, not transient — the errno
+ * describes how the OS reported it, not what actually failed). Everything
+ * else — including an error with no `code` at all — is genuine.
+ */
+function classifyAstGrepLoadFailure(err) {
+    const { codes, messages } = collectErrorChain(err);
+    const hasKnownGenuineMessage = messages.some((message) => KNOWN_GENUINE_NATIVE_LOAD_MESSAGES.some((pattern) => pattern.test(message)));
+    if (hasKnownGenuineMessage)
+        return "genuine";
+    const hasTransientErrno = codes.some((code) => TRANSIENT_ERRNO_ALLOWLIST.has(code));
+    return hasTransientErrno ? "transient" : "genuine";
+}
+function recordAstGrepUnavailableOnce(reason) {
+    recordDegradationOnce({
+        kind: "ast-grep-napi-unavailable",
+        subject: "ast-grep-napi",
+        reason: reason === "genuine"
+            ? "native addon failed to load (durable for this session)"
+            : "native addon load hit a transient error (durable for this session — see sgSessionHold doc)",
+    });
+}
 export async function loadSg() {
     if (sg)
         return sg;
-    if (sgLoadAttempted)
-        return undefined; // Don't retry if already failed
-    sgLoadAttempted = true;
-    try {
-        sg = await loadAstGrepNapi();
-        return sg;
-    }
-    catch {
+    if (sgLoadPromise)
+        return sgLoadPromise;
+    if (sgSessionHold) {
+        // #1567 review F4: a held/degraded load must be distinguishable from a
+        // clean scan that found nothing to report, not silently read as
+        // "skipped/empty" by every caller (clients/project-diagnostics/scanner.ts,
+        // this file's own runner) — otherwise the two are indistinguishable in
+        // the degradation ledger.
+        recordAstGrepUnavailableOnce(sgHoldReason ?? "genuine");
         return undefined;
     }
+    const task = (async () => {
+        try {
+            const loaded = await loadAstGrepNapi();
+            sg = loaded;
+            return loaded;
+        }
+        catch (err) {
+            const reason = classifyAstGrepLoadFailure(err);
+            sgSessionHold = true;
+            sgHoldReason = reason;
+            recordAstGrepUnavailableOnce(reason);
+            return undefined;
+        }
+    })();
+    sgLoadPromise = task;
+    task.finally(() => {
+        if (sgLoadPromise === task)
+            sgLoadPromise = undefined;
+    });
+    return task;
+}
+/**
+ * Re-arm the napi load latch for a new session (#1567). `sg` itself is left
+ * alone — a successful load stays valid and cached for the process — but a
+ * session hold (transient or genuine) is session-scoped state and must not
+ * outlive the session that set it. Called from `resetDispatchBaselines()`
+ * (clients/dispatch/integration.ts) beside `resetAstGrepUnsupportedLanguageLog`,
+ * this module's other session latch.
+ */
+export function resetAstGrepNapiLoadState() {
+    sgSessionHold = false;
+    sgHoldReason = undefined;
 }
 // Supported extensions for NAPI
 const SUPPORTED_EXTS = [".ts", ".tsx", ".js", ".jsx", ".css", ".html", ".htm"];
@@ -156,11 +314,21 @@ export function canHandle(filePath) {
  * file. Without this, `language:` reads as a real filter but isn't one for
  * ts↔js pairs, so twin rules sharing a base name (e.g. `hardcoded-url` /
  * `hardcoded-url-js`) both match the same construct in the SAME runner
- * invocation (#657). TSX is deliberately its own grammar here: the primary
- * ast-grep CLI/LSP also treats `tsx` as distinct from `typescript`, so a
- * language-tagged rule only runs on the exact grammar it names. Returns
- * undefined for extensions this scoping doesn't apply to (css/html), where
- * no filtering is added.
+ * invocation (#657). TSX is its own grammar here too — the primary
+ * ast-grep CLI/LSP also treats `tsx` as distinct from `typescript` — but
+ * the caller's language-match check adds ONE deliberate exception on top
+ * of the exact-match rule: a `TypeScript`-tagged rule also runs against
+ * a `.tsx` file's fileLang (#1608). This is grounded empirically, not by
+ * analogy — tsx's grammar is a syntactic superset of typescript's for
+ * every construct the shipped catalog's rules target (JSX productions
+ * added, plus the removal of the `<T>expr` cast form, which cannot
+ * appear in valid `.tsx` source), and every `language: TypeScript`
+ * rule's fixture-test `invalid:` snippet is asserted to still match
+ * parsed as tsx (ast-grep-tsx-coverage.test.ts) rather than assumed.
+ * Without this exception the entire TS ruleset silently never runs on
+ * `.tsx` files. `TSX`-tagged rules stay `.tsx`-exclusive; the exception
+ * is TS→TSX only. Returns undefined for extensions this scoping doesn't
+ * apply to (css/html), where no filtering is added.
  */
 export function ruleLanguageForFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
@@ -229,6 +397,29 @@ function appendDuplicateRuleDiagnostics(diagnostics, seenRuleIds, duplicateIds,
     }
     return false;
 }
+/**
+ * The four tiers `Diagnostic.severity` accepts (clients/dispatch/types.ts).
+ * `YamlRule.severity` is a free-form string straight off disk, so an unknown
+ * or missing value must land somewhere deliberate rather than being cast.
+ */
+const DIAGNOSTIC_SEVERITY_TIERS = new Set([
+    "error",
+    "warning",
+    "info",
+    "hint",
+]);
+/**
+ * Map a rule's declared YAML severity onto a `Diagnostic.severity` tier (#1777).
+ *
+ * A rule that declares nothing, or declares a value pi-lens does not model
+ * (ast-grep also accepts `off`), falls back to `warning` — the tier every such
+ * rule already reported at before #1777, so reviving hint/info never silently
+ * demotes an existing rule.
+ */
+export function normalizeRuleSeverity(raw) {
+    const tier = raw;
+    return tier && DIAGNOSTIC_SEVERITY_TIERS.has(tier) ? tier : "warning";
+}
 /**
  * Run the shipped ast-grep YAML ruleset against a parsed file via napi's native
  * engine, applying the same suppression policy (linter/tree-sitter overlap,
@@ -343,9 +534,27 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
             }
             // Scope TypeScript/JavaScript-tagged rules to the file's actual
             // grammar (#657) — otherwise a `-js` twin sharing generic node
-            // kinds with its TS sibling double-fires on every .ts file.
+            // kinds with its TS sibling double-fires on every .ts file. TSX
+            // is the one deliberate exception (#1608): the tsx grammar is a
+            // syntactic superset of typescript's for every non-JSX construct
+            // (the `<T>expr` cast form is the only TS-only production, and
+            // it can't appear in valid .tsx source anyway), so a
+            // `language: TypeScript` rule still matches a tsx-parsed root
+            // and must run there too, or the entire TS ruleset (120 of 263
+            // rules) goes dark on every .tsx file. `language: TSX` rules
+            // stay tsx-exclusive — they're already scoped to fileLang
+            // "tsx" by the exact-match check.
             if (lang && fileLang && lang !== fileLang) {
-                continue;
+                const runsAsTsOnTsx = fileLang === "tsx" && lang === "typescript";
+                if (!runsAsTsOnTsx) {
+                    const key = `mismatch:${lang}->${fileLang}`;
+                    if (!unsupportedLanguageLog.has(key)) {
+                        const ids = newlyUnsupported.get(key) ?? [];
+                        ids.push(rule.id);
+                        newlyUnsupported.set(key, ids);
+                    }
+                    continue;
+                }
             }
             if (blockingOnly && rule.rule) {
                 const complexity = calculateRuleComplexity(rule.rule);
@@ -387,7 +596,14 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
                         break;
                     const node = match;
                     const range = node.range();
-                    const severity = rule.severity === "error" ? "error" : "warning";
+                    // #1777: carry the rule's own tier through. The old collapse
+                    // (`=== "error" ? "error" : "warning"`) erased hint and info,
+                    // so the quiet tier the #1727 anti-slop rules ship at did not
+                    // exist anywhere downstream. `Diagnostic.severity` has been
+                    // 4-valued all along (clients/dispatch/types.ts). The BLOCKING
+                    // gate is unchanged and deliberately narrower: only `error`
+                    // blocks, so hint and info stay advisory exactly like warning.
+                    const severity = normalizeRuleSeverity(rule.severity);
                     const semantic = severity === "error" ? "blocking" : "warning";
                     const defectClass = classifyDefect(rule.id, "ast-grep-napi", rule.message || rule.id);
                     const ruleFix = explicitRuleFixSuggestion(rule);

package/node_modules/pi-lens/dist/clients/dispatch/runners/biome-check.js

@@ -6,33 +6,80 @@
  * mutating files mid-dispatch after LSP sync has already happened.
  */
 import * as path from "node:path";
+import { incrementDegradationCount } from "../../degradation-ledger.js";
+import { mapWithConcurrency } from "../../dependency-checker.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { biomeConfigArgs, getAutofixCapability, getJstsLintPolicyForCwd, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
-function parseBiomeJson(raw, filePath) {
+/**
+ * Map biome's own severity vocabulary onto the four-tier `Diagnostic.severity`
+ * (clients/dispatch/types.ts), the same way `normalizeRuleSeverity` does for
+ * ast-grep-napi post-#1787. Biome's real `lint --reporter=json` output
+ * (re-probed live for #1810's review round) spells its info tier `"info"`,
+ * not `"information"` — the value this switch matched before, which meant a
+ * real info-tier diagnostic fell through the `default` and was silently
+ * promoted to `"warning"`, one tier too loud. Every other tier is a direct
+ * pass-through; an unrecognized value still falls back to `"warning"` — the
+ * tier every biome diagnostic reported at before this fix, so reviving
+ * hint/info never silently demotes an existing finding.
+ */
+export function normalizeBiomeSeverity(raw) {
+    switch (raw) {
+        case "error":
+            return "error";
+        case "info":
+            return "info";
+        case "hint":
+            return "hint";
+        case "warning":
+            return "warning";
+        default:
+            return "warning";
+    }
+}
+/**
+ * A diagnostic's `category` is `"lint/<group>/<ruleName>"` — extracts the
+ * bare rule name `biome explain` expects. Returns `undefined` for anything
+ * that isn't a `lint/` category (e.g. a parse-error pseudo-category), so
+ * callers never look up fixability for a rule that was never a real rule.
+ */
+export function biomeRuleNameFromCategory(category) {
+    if (!category?.startsWith("lint/"))
+        return undefined;
+    const parts = category.split("/");
+    return parts[parts.length - 1] || undefined;
+}
+export function parseBiomeJson(raw, filePath, fixKindByRule) {
     try {
         const result = JSON.parse(raw);
         const diagnostics = result.diagnostics || [];
         const autofix = getAutofixCapability("biome");
         return {
-            diagnostics: diagnostics.map((d) => ({
-                id: `biome:${d.category}:${d.location.start.line}`,
-                message: d.message,
-                filePath,
-                line: d.location.start.line,
-                column: d.location.start.column,
-                severity: d.severity === "error" ? "error" : "warning",
-                semantic: d.severity === "error" ? "blocking" : "warning",
-                tool: "biome",
-                rule: d.category,
-                fixable: d.tags?.includes("fixable") ?? false,
-                autoFixAvailable: (d.tags?.includes("fixable") ?? false) &&
-                    (autofix?.safePipelineAutofix ?? false),
-                fixKind: d.tags?.includes("fixable") && autofix?.fixKind !== "none"
-                    ? autofix?.fixKind
-                    : undefined,
-            })),
+            diagnostics: diagnostics.map((d) => {
+                const ruleName = biomeRuleNameFromCategory(d.category);
+                const fixKind = ruleName ? fixKindByRule?.get(ruleName) : undefined;
+                const isFixable = fixKind === "safe" || fixKind === "unsafe";
+                return {
+                    id: `biome:${d.category}:${d.location.start.line}`,
+                    message: d.message,
+                    filePath,
+                    line: d.location.start.line,
+                    column: d.location.start.column,
+                    severity: normalizeBiomeSeverity(d.severity),
+                    semantic: d.severity === "error" ? "blocking" : "warning",
+                    tool: "biome",
+                    rule: d.category,
+                    fixable: isFixable,
+                    // Mirrors `biomeClient.fixFileAsync`'s own `lint --write` call
+                    // (no `--unsafe`, clients/biome-client.ts): the pipeline only
+                    // ever applies SAFE fixes, so only "safe" earns autoFixAvailable.
+                    autoFixAvailable: fixKind === "safe" && (autofix?.safePipelineAutofix ?? false),
+                    fixKind: isFixable && autofix?.fixKind !== "none"
+                        ? autofix?.fixKind
+                        : undefined,
+                };
+            }),
         };
     }
     catch (err) {
@@ -42,6 +89,109 @@ function parseBiomeJson(raw, filePath) {
         };
     }
 }
+// Process-lifetime cache: a rule's fix kind is a static property of the
+// (biome binary, rule name) pair, not of any one diagnostic occurrence, so
+// it's resolved once and reused. Keyed on the resolved `cmd` so a different
+// biome binary (e.g. a different project's pinned version) never reuses
+// another binary's answer. Registered in
+// tests/support/session-state-registry.ts as `process_lifetime` — the
+// answer cannot change without a different biome binary, which is a
+// different cache key, so there is nothing for a session boundary to
+// invalidate.
+const biomeFixKindCache = new Map();
+/** Test-only: drop every cached verdict so a test starts from a clean cache. */
+export function _resetBiomeFixKindCacheForTests() {
+    biomeFixKindCache.clear();
+}
+const BIOME_FIX_KIND_PATTERN = /^-\s*Fix:\s*(safe|unsafe)\s*$/m;
+// The explicit "no fix" statement `biome explain` prints for a rule with no
+// autofix at all (e.g. `noConstantCondition`). Matching this SEPARATELY from
+// "the safe/unsafe pattern didn't match" is the point (#1810 review F1/F2):
+// only a POSITIVE read — either a stated fix tier or this explicit negative
+// — is trustworthy enough to cache. Anything else (a differently-shaped
+// `explain` output, e.g. a biome 1.x install) is a parse failure, not a
+// verdict, and must never be cached as one.
+const BIOME_NO_FIX_PATTERN = /^-\s*No fix available\.\s*$/m;
+/** At most this many `biome explain` spawns run concurrently (#1810 review F6). */
+const EXPLAIN_CONCURRENCY = 4;
+/**
+ * Resolves each rule referenced by `categories` to its fix kind via
+ * `biome explain <rule>` — the one place biome's shipped CLI states
+ * fixability as structured text (`- Fix: safe|unsafe`, or `- No fix
+ * available.` when absent), sourced live from the running binary's own rule
+ * registry rather than a hand-maintained table (#1810; real diagnostics
+ * carry no per-occurrence fixability field — see `BiomeDiagnostic`).
+ *
+ * Only a POSITIVE read is cached: either `- Fix: safe|unsafe` or the
+ * explicit `- No fix available.` statement. A spawn failure, a nonzero
+ * exit, or output that matches NEITHER pattern (e.g. a biome 1.x install —
+ * its `explain` text differs and would otherwise poison every rule as
+ * permanently unfixable, #1810 review F1) resolves to `"none"` for THIS
+ * call only and is never written to the cache — caching an unparsed result
+ * would permanently under-report a genuinely fixable rule for the rest of
+ * the process's life (the never-cache-a-transient-failure screen).
+ */
+export async function resolveBiomeFixKinds(cmd, cwd, categories) {
+    const resolved = new Map();
+    const ruleNames = new Set();
+    for (const category of categories) {
+        const ruleName = biomeRuleNameFromCategory(category);
+        if (ruleName)
+            ruleNames.add(ruleName);
+    }
+    const toResolve = [];
+    for (const ruleName of ruleNames) {
+        const cacheKey = `${cmd}::${ruleName}`;
+        const cached = biomeFixKindCache.get(cacheKey);
+        if (cached === undefined) {
+            toResolve.push(ruleName);
+        }
+        else {
+            resolved.set(ruleName, cached);
+        }
+    }
+    await mapWithConcurrency(toResolve, EXPLAIN_CONCURRENCY, async (ruleName) => {
+        const cacheKey = `${cmd}::${ruleName}`;
+        const spawned = await safeSpawnAsync(cmd, ["explain", ruleName], {
+            timeout: 10000,
+            cwd,
+        });
+        if (spawned.error || spawned.status !== 0) {
+            incrementDegradationCount({
+                kind: "biome-explain-unavailable",
+                subject: ruleName,
+                reason: spawned.error
+                    ? `spawn failed: ${spawned.error}`
+                    : `explain exited ${spawned.status}`,
+            });
+            resolved.set(ruleName, "none");
+            return;
+        }
+        const stdout = spawned.stdout || "";
+        const fixMatch = stdout.match(BIOME_FIX_KIND_PATTERN);
+        if (fixMatch) {
+            const kind = fixMatch[1] === "safe" ? "safe" : "unsafe";
+            biomeFixKindCache.set(cacheKey, kind);
+            resolved.set(ruleName, kind);
+            return;
+        }
+        if (BIOME_NO_FIX_PATTERN.test(stdout)) {
+            biomeFixKindCache.set(cacheKey, "none");
+            resolved.set(ruleName, "none");
+            return;
+        }
+        // Neither pattern matched — an unrecognized `explain` output shape, not
+        // a confirmed negative. Resolve to "none" for this call, but leave the
+        // cache untouched so the next batch retries against real output.
+        incrementDegradationCount({
+            kind: "biome-explain-unavailable",
+            subject: ruleName,
+            reason: "explain output matched neither the Fix nor No-fix pattern",
+        });
+        resolved.set(ruleName, "none");
+    });
+    return resolved;
+}
 const biomeCheckJsonRunner = {
     id: "biome-check-json",
     appliesTo: ["jsts"],
@@ -75,8 +225,26 @@ const biomeCheckJsonRunner = {
         if (checkResult.error) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
+        let fixKindByRule;
+        if (checkResult.status === 0 || checkResult.status === 1) {
+            // Cheap pre-parse just to collect rule categories — the real parse
+            // (with parseError handling) happens below via parseBiomeJson. A
+            // malformed-JSON pre-parse simply yields no categories, and
+            // `resolveBiomeFixKinds` no-ops on an empty list (no spawn, an
+            // immediately-resolved empty map) — the real parse still surfaces
+            // the parseError diagnostic as before.
+            let categories = [];
+            try {
+                const preParsed = JSON.parse(checkResult.stdout || "{}");
+                categories = (preParsed.diagnostics || []).map((d) => d.category);
+            }
+            catch {
+                categories = [];
+            }
+            fixKindByRule = await resolveBiomeFixKinds(cmd, cwd, categories);
+        }
         const parsed = checkResult.status === 0 || checkResult.status === 1
-            ? parseBiomeJson(checkResult.stdout || "", ctx.filePath)
+            ? parseBiomeJson(checkResult.stdout || "", ctx.filePath, fixKindByRule)
             : { diagnostics: [] };
         if (parsed.parseError) {
             const raw = checkResult.stdout || checkResult.stderr || "";

package/node_modules/pi-lens/dist/clients/dispatch/runners/cpp-check.js

@@ -124,7 +124,9 @@ function parseGccLikeOutput(raw, filePath) {
             line: Number.parseInt(lineStr, 10) || 1,
             column: Number.parseInt(colStr || "1", 10) || 1,
             severity,
-            semantic: severity === "error" ? "blocking" : "warning",
+            // This single-file syntax check has no compile database, include path,
+            // or build flags. It can inform, but cannot prove a project blocker.
+            semantic: "warning",
             tool: "cpp-check",
             rule: severityLabel.toLowerCase(),
             fixable: false,
@@ -153,7 +155,8 @@ function parseMsvcOutput(raw, filePath) {
             line: Number.parseInt(lineStr, 10) || 1,
             column: Number.parseInt(colStr || "1", 10) || 1,
             severity,
-            semantic: severity === "error" ? "blocking" : "warning",
+            // MSVC is invoked with the same context-free single-file contract.
+            semantic: "warning",
             tool: "cpp-check",
             rule,
             fixable: false,
@@ -217,7 +220,7 @@ const cppCheckRunner = {
         return {
             status: hasErrors ? "failed" : "succeeded",
             diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
+            semantic: "warning",
             rawOutput: raw,
         };
     },

package/node_modules/pi-lens/dist/clients/dispatch/runners/credo.js

@@ -3,15 +3,17 @@ import * as fs from "node:fs";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { PRIORITY } from "../priorities.js";
 import { createCwdCachedProbe } from "./utils/runner-helpers.js";
-// Per-cwd cached `mix credo --version` probe (#120). Before this, the probe
-// fired on every Elixir file save in projects with mix.exs.
-const probeCredo = createCwdCachedProbe(async (cwd) => {
-    const r = await safeSpawnAsync("mix", ["credo", "--version"], {
-        timeout: 10000,
-        cwd,
-    });
-    return !r.error && r.status === 0;
-});
+const CREDO_PROBE_BUDGET_MS = 10_000;
+// Per-cwd cached `mix credo --version` probe (#120), governed by the shared
+// availability policy (#1494). The probe returns the spawn result so the policy
+// can tell a cold-BEAM timeout from a genuinely absent credo: the 10 s budget
+// here is the widest in the repo and the most likely to expire on a slow first
+// compile, and latching that as "not installed" used to disable credo for the
+// rest of the session.
+const probeCredo = createCwdCachedProbe((cwd) => safeSpawnAsync("mix", ["credo", "--version"], {
+    timeout: CREDO_PROBE_BUDGET_MS,
+    cwd,
+}), { tool: "credo", budgetMs: CREDO_PROBE_BUDGET_MS });
 // `mix credo <file>` is single-file-scoped today, so blanket attribution would
 // be correct — but map issue.filename (resolved against cwd) for robustness so
 // this stays correct if the invocation ever widens to a directory (#265 A4).