pi-lens 3.8.73 → 3.8.74

package/dist/clients/dispatch/facts/import-facts.js

@@ -1,5 +1,5 @@
 import { logLatency } from "../../latency-logger.js";
-import { childrenOfType, firstChildOfType, parseFactTree, walk, } from "./tree-sitter-facts.js";
+import { childrenOfType, firstChildOfType, withFactTree, walk, } from "./tree-sitter-facts.js";
 // JS/TS extensions this provider handles (→ tree-sitter typescript/tsx/javascript
 // grammars via resolveTreeSitterLanguage). Ported off the `typescript` compiler API
 // onto tree-sitter (#402) — the parse is served from the shared, cached client.
@@ -96,115 +96,114 @@ export const importFactProvider = {
         }
         // Grammar unavailable / parse failed / wasm aborted — degrade to empty
         // (there is no typescript-compiler fallback by design, #402).
-        const root = await parseFactTree(ctx.filePath, content);
-        if (!root) {
-            setEmpty();
-            return;
-        }
-        // --- module-type detection + static import/re-export node collection ---
-        let hasEsm = false;
-        let hasCjs = false;
-        const importNodes = [];
-        const reExportNodes = [];
-        for (const child of root.children ?? []) {
-            if (!child)
-                continue;
-            if (child.type === "import_statement") {
-                hasEsm = true;
-                importNodes.push(child);
-            }
-            else if (child.type === "export_statement") {
-                const isReExport = Boolean(firstChildOfType(child, "string"));
-                // `export { x }` / `export * from` / `export { x } from` are ESM
-                // declarations (like TS's isExportDeclaration); `export const x` /
-                // `export default` (a wrapped declaration) is NOT counted here.
-                if (isReExport || firstChildOfType(child, "export_clause")) {
+        const parsed = await withFactTree(ctx.filePath, content, (root) => {
+            // --- module-type detection + static import/re-export node collection ---
+            let hasEsm = false;
+            let hasCjs = false;
+            const importNodes = [];
+            const reExportNodes = [];
+            for (const child of root.children ?? []) {
+                if (!child)
+                    continue;
+                if (child.type === "import_statement") {
                     hasEsm = true;
+                    importNodes.push(child);
+                }
+                else if (child.type === "export_statement") {
+                    const isReExport = Boolean(firstChildOfType(child, "string"));
+                    // `export { x }` / `export * from` / `export { x } from` are ESM
+                    // declarations (like TS's isExportDeclaration); `export const x` /
+                    // `export default` (a wrapped declaration) is NOT counted here.
+                    if (isReExport || firstChildOfType(child, "export_clause")) {
+                        hasEsm = true;
+                    }
+                    if (isReExport)
+                        reExportNodes.push(child);
                 }
-                if (isReExport)
-                    reExportNodes.push(child);
             }
-        }
-        // --- dynamic import() / require() / module.exports (anywhere in the tree) ---
-        const dynamicRaw = [];
-        walk(root, (node) => {
-            if (node.type === "call_expression") {
-                const callee = node.children?.[0];
-                const args = firstChildOfType(node, "arguments");
-                const strArg = args ? firstChildOfType(args, "string") : undefined;
-                if (!strArg)
-                    return; // non-string arg (e.g. template literal) — skip
-                const source = stripQuotes(strArg.text);
-                if (callee?.type === "import") {
-                    dynamicRaw.push({ source, kind: "import" });
+            // --- dynamic import() / require() / module.exports (anywhere in the tree) ---
+            const dynamicRaw = [];
+            walk(root, (node) => {
+                if (node.type === "call_expression") {
+                    const callee = node.children?.[0];
+                    const args = firstChildOfType(node, "arguments");
+                    const strArg = args ? firstChildOfType(args, "string") : undefined;
+                    if (!strArg)
+                        return; // non-string arg (e.g. template literal) — skip
+                    const source = stripQuotes(strArg.text);
+                    if (callee?.type === "import") {
+                        dynamicRaw.push({ source, kind: "import" });
+                    }
+                    else if (callee?.type === "identifier" && callee.text === "require") {
+                        dynamicRaw.push({ source, kind: "require" });
+                        hasCjs = true;
+                    }
                 }
-                else if (callee?.type === "identifier" && callee.text === "require") {
-                    dynamicRaw.push({ source, kind: "require" });
-                    hasCjs = true;
+                else if (node.type === "member_expression") {
+                    // module.exports = ...
+                    const obj = node.children?.[0];
+                    if (obj?.type === "identifier" && obj.text === "module") {
+                        const prop = firstChildOfType(node, "property_identifier");
+                        if (prop?.text === "exports")
+                            hasCjs = true;
+                    }
                 }
+            });
+            const moduleType = hasEsm && !hasCjs
+                ? "esm"
+                : hasCjs && !hasEsm
+                    ? "cjs"
+                    : hasEsm || hasCjs
+                        ? "esm" // mixed — static imports present, treat as ESM
+                        : "unknown";
+            // --- build entries ---
+            const imports = [];
+            for (const node of importNodes) {
+                const entry = parseStaticImport(node, moduleType);
+                if (entry)
+                    imports.push(entry);
             }
-            else if (node.type === "member_expression") {
-                // module.exports = ...
-                const obj = node.children?.[0];
-                if (obj?.type === "identifier" && obj.text === "module") {
-                    const prop = firstChildOfType(node, "property_identifier");
-                    if (prop?.text === "exports")
-                        hasCjs = true;
+            let dynamicCount = 0;
+            for (const d of dynamicRaw) {
+                if (d.kind === "import") {
+                    imports.push({
+                        source: d.source,
+                        names: [],
+                        isDynamic: true,
+                        moduleType,
+                    });
+                }
+                else {
+                    imports.push({ source: d.source, names: [], moduleType: "cjs" });
                 }
+                dynamicCount++;
             }
-        });
-        const moduleType = hasEsm && !hasCjs
-            ? "esm"
-            : hasCjs && !hasEsm
-                ? "cjs"
-                : hasEsm || hasCjs
-                    ? "esm" // mixed — static imports present, treat as ESM
-                    : "unknown";
-        // --- build entries ---
-        const imports = [];
-        for (const node of importNodes) {
-            const entry = parseStaticImport(node, moduleType);
-            if (entry)
-                imports.push(entry);
-        }
-        let dynamicCount = 0;
-        for (const d of dynamicRaw) {
-            if (d.kind === "import") {
-                imports.push({
-                    source: d.source,
-                    names: [],
-                    isDynamic: true,
-                    moduleType,
-                });
+            store.setFileFact(ctx.filePath, "file.imports", imports);
+            const reexports = [];
+            for (const node of reExportNodes) {
+                const r = parseReExport(node);
+                if (r)
+                    reexports.push(r);
             }
-            else {
-                imports.push({ source: d.source, names: [], moduleType: "cjs" });
+            store.setFileFact(ctx.filePath, "file.reexports", reexports);
+            // Telemetry: log when a file has dynamic imports or re-exports so we can
+            // measure coverage and validate the implementation across real projects.
+            if (dynamicCount > 0 || reexports.length > 0) {
+                logLatency({
+                    type: "call_graph_facts",
+                    filePath: ctx.filePath,
+                    durationMs: 0,
+                    metadata: {
+                        moduleType,
+                        staticImports: imports.length - dynamicCount,
+                        dynamicImports: dynamicCount,
+                        reexports: reexports.length,
+                        starReexports: reexports.filter((r) => r.names.length === 0).length,
+                    },
+                });
             }
-            dynamicCount++;
-        }
-        store.setFileFact(ctx.filePath, "file.imports", imports);
-        const reexports = [];
-        for (const node of reExportNodes) {
-            const r = parseReExport(node);
-            if (r)
-                reexports.push(r);
-        }
-        store.setFileFact(ctx.filePath, "file.reexports", reexports);
-        // Telemetry: log when a file has dynamic imports or re-exports so we can
-        // measure coverage and validate the implementation across real projects.
-        if (dynamicCount > 0 || reexports.length > 0) {
-            logLatency({
-                type: "call_graph_facts",
-                filePath: ctx.filePath,
-                durationMs: 0,
-                metadata: {
-                    moduleType,
-                    staticImports: imports.length - dynamicCount,
-                    dynamicImports: dynamicCount,
-                    reexports: reexports.length,
-                    starReexports: reexports.filter((r) => r.names.length === 0).length,
-                },
-            });
-        }
+        });
+        if (!parsed.parsed)
+            setEmpty();
     },
 };

package/dist/clients/dispatch/facts/tree-sitter-facts.js

@@ -2,15 +2,14 @@
  * Fact-provider-specific tree-sitter helper (#402).
  *
  * The generic node-walk utilities (`walk`, `childrenOfType`, `firstChildOfType`,
- * `parseTreeSitterRoot`, `TsNode`) live in `clients/tree-sitter-shared.ts` so both
+ * `withTreeSitterRoot`, `TsNode`) live in `clients/tree-sitter-shared.ts` so both
  * the fact extractors and the complexity client share them. This module re-exports
  * them for the extractors and adds the FactProvider-specific `extractFactsFromTree`
  * shell.
  */
-import { childrenOfType, firstChildOfType, parseTreeSitterRoot, walk, } from "../../tree-sitter-shared.js";
+import { childrenOfType, firstChildOfType, withTreeSitterRoot, walk, } from "../../tree-sitter-shared.js";
 export { childrenOfType, firstChildOfType, walk, };
-/** Parse `content` for `filePath` into a root node (or null). Alias of the shared helper. */
-export const parseFactTree = parseTreeSitterRoot;
+export const withFactTree = withTreeSitterRoot;
 /**
  * Provider shell for tree-sitter-backed fact extractors: read `file.content`,
  * parse via the shared client, and hand the root node to `extract`. On empty
@@ -27,8 +26,6 @@ export async function extractFactsFromTree(ctx, store, defaults, extract) {
     const content = store.getFileFact(ctx.filePath, "file.content");
     if (!content)
         return writeAll(defaults);
-    const root = await parseFactTree(ctx.filePath, content);
-    if (!root)
-        return writeAll(defaults);
-    writeAll(extract(root, content));
+    const parsed = await withFactTree(ctx.filePath, content, (root) => extract(root, content));
+    writeAll(parsed.parsed ? parsed.value : defaults);
 }

package/dist/clients/dispatch/facts/try-catch-facts.js

@@ -1,5 +1,16 @@
 import { extractFactsFromTree, firstChildOfType, walk, } from "./tree-sitter-facts.js";
 // --- Helpers ---
+/** Does `node`'s subtree contain an `assignment_expression` (`x = ...`, `x += ...`, …)? */
+function hasAssignmentExpression(node) {
+    if (!node)
+        return false;
+    let found = false;
+    walk(node, (n) => {
+        if (n.type === "assignment_expression")
+            found = true;
+    });
+    return found;
+}
 function isOnlyWhitespaceOrComments(text) {
     let stripped = text.replace(/\/\*[\s\S]*?\*\//g, "");
     stripped = stripped.replace(/\/\/[^\n]*/g, "");
@@ -74,6 +85,7 @@ export const tryCatchFactProvider = {
                 const catchReturnsDefault = DEFAULT_VALUE_PATTERN.test(bodyText);
                 const catchReturnsStructuredError = STRUCTURED_ERROR_PATTERN.test(bodyText);
                 const isDocumentedLocalFallback = EXPLAINING_COMMENT_PATTERN.test(bodyText);
+                const catchHasFallbackAssignment = hasAssignmentExpression(catchBody);
                 const catchLogsOnly = hasLogging &&
                     !hasRethrow &&
                     !catchReturnsDefault &&
@@ -95,6 +107,7 @@ export const tryCatchFactProvider = {
                     catchReturnsDefault,
                     catchReturnsStructuredError,
                     isDocumentedLocalFallback,
+                    catchHasFallbackAssignment,
                     tryResolvesLocalValues,
                     isFilesystemExistenceProbe,
                     boundaryCategory,

package/dist/clients/dispatch/integration.js

@@ -25,8 +25,8 @@ import { getServersForFileWithConfig } from "../lsp/config.js";
 import { getLSPService } from "../lsp/index.js";
 import { isExternalOrVendorFile, normalizeMapKey } from "../path-utils.js";
 import { getProjectIgnoreMatcher } from "../file-utils.js";
-import { clearReviewGraphWorkspaceCache, getLastGraphBuildInfo, } from "../review-graph/builder.js";
-import { buildReverseDependencyIndexFromGraph, getAffectedFilesFromIndex, writeReverseDependencyIndexToSnapshot, } from "../reverse-deps.js";
+import { clearReviewGraphWorkspaceCache, getGraphImportChanges, getLastGraphBuildInfo, } from "../review-graph/builder.js";
+import { buildReverseDependencyIndexFromGraph, getAffectedFilesFromIndex, patchReverseDependencyIndex, writeReverseDependencyIndexToSnapshot, } from "../reverse-deps.js";
 import { buildOrUpdateGraph, computeImpactCascade, computeTransitiveImpact, formatImpactCascade, } from "../review-graph/service.js";
 import { clearModuleGraphCache } from "../review-graph/workspace-modules.js";
 import { RUNTIME_CONFIG } from "../runtime-config.js";
@@ -498,17 +498,15 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
     // `wordIndex`/`fileContent` doc comments for the cold/no-forward-index
     // no-op rules.
     //
-    // Deliberately keyed by `path.resolve(filePath)`, NOT `normalizedFile`
-    // (which is `normalizeMapKey`'d — realpath-canonicalized + lowercased on
-    // Windows). The word index's OWN keys come from `collectWordIndexDocs` →
-    // `collectSourceFilesAsync`'s file walk, which yields plain
-    // `path.resolve()`-joined paths (native separators, on-disk casing as
-    // reported by the walk, no realpath call). Keying this update with the
-    // cascade's normalized key would silently create a SECOND, orphaned entry
-    // next to the walker's original-cased entry instead of replacing it —
-    // exactly the kind of divergence the equivalence-property test is meant to
-    // catch, so the key shape here must match the build path's, not the
-    // cascade/graph's own (different) normalization scheme.
+    // Keyed by `path.resolve(filePath)` (native separators, tool-input casing).
+    // Since #1025 the word index's path maps are `PathKeyedMap`s that fold every
+    // key through `wordIndexKey` (`normalizeEphemeralMapKey` — slash-fold +
+    // win32-lowercase) INTERNALLY, so this per-edit key and the build path's own
+    // walk-derived key (`collectWordIndexDocs` → `collectSourceFilesAsync`)
+    // collapse to the same entry regardless of on-disk-vs-input casing/separator.
+    // The old hazard — this update silently orphaning a SECOND entry next to the
+    // walker's original-cased one — is now structurally impossible at the map
+    // layer, so this seam no longer has to hand-match the build path's key shape.
     updateWordIndexForCascade({
         wordIndex,
         filePath: nodePath.resolve(filePath),
@@ -544,15 +542,32 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
         const graphBuildInfo = getLastGraphBuildInfo();
         const workspaceKey = normalizeMapKey(cwd);
         const cachedReverseDeps = reverseDepsIndexCache.get(workspaceKey);
+        const importDelta = getGraphImportChanges(graph);
+        // A one-step delta is only usable against an index cached at exactly the
+        // delta's predecessor generation. Builds minted elsewhere (mcp analyze,
+        // lens-map, session warm) advance generations whose import changes this
+        // delta does not cover — reusing/patching across that gap stamps a stale
+        // index as current, and generation equality then hides the loss forever
+        // (#939 review finding 1).
+        const deltaContiguous = importDelta !== undefined &&
+            importDelta.fromGeneration !== undefined &&
+            cachedReverseDeps !== undefined &&
+            cachedReverseDeps.generation === importDelta.fromGeneration;
+        const importChanges = deltaContiguous ? importDelta.changes : undefined;
+        const importsChanged = importChanges?.some((change) => change.existedBefore !== change.existsAfter ||
+            change.priorTargets.length !== change.newTargets.length ||
+            change.priorTargets.some((target, index) => target !== change.newTargets[index]));
         const canReuse = reverseDepsReuseEnabled() &&
             cachedReverseDeps !== undefined &&
-            graph.buildGeneration !== undefined &&
-            cachedReverseDeps.generation === graph.buildGeneration;
+            ((graph.buildGeneration !== undefined &&
+                cachedReverseDeps.generation === graph.buildGeneration) ||
+                (importChanges !== undefined && !importsChanged));
         let reverseDepsIndex;
         let reverseDepsSaved;
         if (canReuse && cachedReverseDeps) {
             reverseDepsIndex = cachedReverseDeps.index;
             reverseDepsSaved = cachedReverseDeps.savedToSnapshot;
+            cachedReverseDeps.generation = graph.buildGeneration;
             logCascade({
                 phase: "reverse_deps_cache",
                 filePath,
@@ -565,6 +580,29 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 },
             });
         }
+        else if (cachedReverseDeps && importChanges && importsChanged) {
+            reverseDepsIndex = patchReverseDependencyIndex(cachedReverseDeps.index, importChanges);
+            reverseDepsSaved = writeReverseDependencyIndexToSnapshot({
+                cwd,
+                index: reverseDepsIndex,
+                dbg,
+            });
+            reverseDepsIndexCache.set(workspaceKey, {
+                index: reverseDepsIndex,
+                savedToSnapshot: reverseDepsSaved,
+                generation: graph.buildGeneration,
+            });
+            logCascade({
+                phase: "reverse_deps_cache",
+                filePath,
+                durationMs: Date.now() - graphStart,
+                metadata: {
+                    action: "patched_import_changes",
+                    changedFileCount: importChanges.length,
+                    savedToSnapshot: reverseDepsSaved,
+                },
+            });
+        }
         else {
             reverseDepsIndex = buildReverseDependencyIndexFromGraph({
                 cwd,
@@ -614,6 +652,29 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
             },
         });
         impact = computeImpactCascade(graph, normalizedFile, cwd);
+        // #1023: buildOrUpdateGraph returns an EMPTY graph (seeded only with the
+        // changed file's own symbols) when the repo is over
+        // PI_LENS_REVIEW_GRAPH_MAX_FILES (`too_many_files`) or the root is unsafe
+        // (`unsafe_root`) — both stamp mode "skipped" on the already-read
+        // graphBuildInfo. Computing impact against that empty graph yields zero
+        // neighbors for EVERY edit, indistinguishable from a genuine clean leaf.
+        // Thread the ALREADY-KNOWN degraded state (never re-derived) onto the
+        // result so the turn-end seam surfaces an honest advisory instead of a
+        // silent all-clear (#533). Keyed strictly off the degraded build mode —
+        // NOT off `neighborFiles.length === 0` — so a healthy build with a real
+        // empty dependent set stays silent (no crying wolf).
+        if (graphBuildInfo.mode === "skipped" && !impact.indeterminate) {
+            impact.indeterminate = {
+                reason: "graph_degraded",
+                detail: graphBuildInfo.skipReason === "too_many_files"
+                    ? `review graph disabled — ${graphBuildInfo.sourceFileCount ?? "?"} files over the ${graphBuildInfo.maxFileCount ?? "?"} cap`
+                    : graphBuildInfo.skipReason === "unsafe_root"
+                        ? "review graph skipped — workspace root is at/above home dir"
+                        : `review graph unavailable (${graphBuildInfo.skipReason ?? "skipped"})`,
+                sourceFileCount: graphBuildInfo.sourceFileCount,
+                maxFileCount: graphBuildInfo.maxFileCount,
+            };
+        }
         const reverseDepNeighbors = getAffectedFilesFromIndex(reverseDepsIndex, normalizedFile, 1, MAX_FILES * 2);
         logCascade({
             phase: "reverse_deps_cache",
@@ -1117,6 +1178,20 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
     cascadeSessionStats.diagnosticsSurfaced += diagCount;
     cascadeSessionStats.coldSnapshotTouches += coldSnapshotPaths.length;
     if (!formatted) {
+        // #1023: an indeterminate compute (degraded/cold/missing-node graph) must
+        // NOT collapse into "no_neighbors" — that is the exact silent all-clear the
+        // bug is about. Distinguish it by the marker threaded onto `impact`, never
+        // by `visibleNeighbors.length === 0` alone (a healthy leaf is also empty).
+        if (impact.indeterminate) {
+            return {
+                filePath,
+                result: undefined,
+                neighborCount: visibleNeighbors.length,
+                diagnosticCount: diagCount,
+                skipReason: "indeterminate",
+                indeterminate: impact.indeterminate,
+            };
+        }
         const skipReason = visibleNeighbors.length === 0 ? "no_neighbors" : "clean";
         return {
             filePath,
@@ -1132,6 +1207,10 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
         result: { filePath, impact, neighbors: visibleNeighbors, formatted },
         neighborCount: visibleNeighbors.length,
         diagnosticCount: diagCount,
+        // #1023: even when some fallback neighbors surfaced, a degraded graph means
+        // the dependent set is INCOMPLETE — carry the marker so the turn-end seam
+        // still notes downstream impact was under-computed this turn.
+        ...(impact.indeterminate && { indeterminate: impact.indeterminate }),
     };
 }
 function diagnosticDeltaKey(diagnostic) {

package/dist/clients/dispatch/rules/async-noise.js

@@ -18,6 +18,7 @@ export const asyncNoiseRule = {
                 !fn.hasAwait &&
                 !fn.hasReturnAwaitCall &&
                 !fn.isPassThroughWrapper &&
+                !fn.hasExplicitPromiseReturnType &&
                 !ASYNC_INTERFACE_PATTERN.test(fn.name) &&
                 // Skip single-statement functions — likely interface stubs or thin wrappers
                 fn.statementCount > 1) {

package/dist/clients/dispatch/rules/unsafe-boundary.js

@@ -53,6 +53,13 @@ function hasCatchCoverage(fn, catches) {
         // Catch body contains a return statement → structured error result
         if (/\breturn\b/.test(c.bodyText))
             return true;
+        // Catch body falls back by mutating existing state (e.g. extending a
+        // validity window on refresh failure) instead of rethrowing/logging/
+        // returning. That's still a real handler — the exception doesn't
+        // escape uncaught — just expressed via assignment rather than one of
+        // the three shapes above (#969).
+        if (c.catchHasFallbackAssignment)
+            return true;
         return false;
     });
 }

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

@@ -9,6 +9,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadAstGrepNapi, } from "../../deps/ast-grep-napi.js";
+import { minimatch } from "../../deps/minimatch.js";
 import { getAstGrepRuleSources, } from "../../sgconfig.js";
 import { logLatency } from "../../latency-logger.js";
 import { hasEslintConfig } from "../../tool-policy.js";
@@ -120,6 +121,22 @@ function explicitRuleFixSuggestion(rule) {
 function normalizeRuleId(ruleId) {
     return ruleId.replace(/-js$/, "");
 }
+/**
+ * `filePath` relative to `root`, forward-slashed, for matching a rule's
+ * `ignores` globs (#965). Falls back to the absolute (slash-normalized) path
+ * when `filePath` isn't under `root` (e.g. an out-of-tree temp file), so a
+ * glob like `scripts/**` simply never matches rather than throwing.
+ */
+function relativeForIgnoreGlob(filePath, root) {
+    const rel = path.relative(root, filePath);
+    return (rel.startsWith("..") ? filePath : rel).split(path.sep).join("/");
+}
+function matchesRuleIgnores(filePath, root, patterns) {
+    if (!patterns || patterns.length === 0)
+        return false;
+    const rel = relativeForIgnoreGlob(filePath, root);
+    return patterns.some((pattern) => minimatch(rel, pattern, { dot: true }));
+}
 export function canHandle(filePath) {
     return SUPPORTED_EXTS.includes(path.extname(filePath).toLowerCase());
 }
@@ -248,7 +265,8 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
     };
     // Shared with the raw sgconfig materializer so both surfaces walk the same
     // workspace-rooted sources in the same precedence order.
-    const ruleSources = getAstGrepRuleSources(options.projectRoot ?? cwd);
+    const ignoreRoot = options.projectRoot ?? cwd;
+    const ruleSources = getAstGrepRuleSources(ignoreRoot);
     for (const source of ruleSources) {
         let rules;
         try {
@@ -275,6 +293,11 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
             seenRuleIds.add(rule.id);
             if (blockingOnly && rule.severity !== "error")
                 continue;
+            // Per-rule path carve-out (#965): a rule that's noise on CLI scripts or
+            // a project's own logging sink (e.g. no-console-except-error firing
+            // inside scripts/** or lib/logger.ts) opts out via `ignores`.
+            if (matchesRuleIgnores(filePath, ignoreRoot, rule.ignores))
+                continue;
             if (suppressLinterOverlap &&
                 LINTER_OVERLAP.has(normalizeRuleId(rule.id)) &&
                 !NON_SUPPRESSIBLE.has(normalizeRuleId(rule.id))) {

package/dist/clients/dispatch/runners/psscriptanalyzer.js

@@ -19,7 +19,16 @@ let psAnalyzerAvailable = undefined;
 const PS_TIMEOUT_MS = 30000;
 function spawnPs(cmd, args, timeoutMs = PS_TIMEOUT_MS) {
     return new Promise((resolve) => {
-        const child = spawn(cmd, args, { windowsHide: true, shell: false });
+        let child;
+        try {
+            child = spawn(cmd, args, { windowsHide: true, shell: false });
+        }
+        catch {
+            // SYNCHRONOUS spawn throw (Windows `spawn UNKNOWN`/EINVAL, the pidusage
+            // bug class, #533) — this best-effort runner must resolve, not reject.
+            resolve({ stdout: "", stderr: "", status: null });
+            return;
+        }
         let stdout = "";
         let stderr = "";
         let settled = false;