@herbertgao/pi-extensions 2026.8.3 → 2026.8.5

package/node_modules/pi-lens/dist/clients/diagnostic-dispositions.js

@@ -56,7 +56,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { writeFileAtomic } from "./atomic-write.js";
+import { commitDurableStore } from "./durable-store.js";
 import { logDispositionEvent } from "./disposition-logger.js";
 import { publishDisposition } from "./disposition-publish.js";
 import { getProjectDataDir } from "./file-utils.js";
@@ -140,11 +140,27 @@ function statePath(cwd) {
     return path.join(getProjectDataDir(cwd), "cache", "diagnostic-dispositions.json");
 }
 let stateCache = null;
+const DISPOSITION_LOCK_WAIT_MS = 2_000;
+const DISPOSITION_LOCK_RETRY_MS = 10;
+let beforeDispositionCommitForTests = null;
+let beforeDispositionCacheRefreshForTests = null;
+let dispositionStatSync = fs.statSync;
+/** Test seam after the caller's cached read and before commit lock acquisition. */
+export function _setBeforeDispositionCommitForTests(hook) {
+    beforeDispositionCommitForTests = hook;
+}
+/** Test seam immediately before the committed state refreshes the cache. */
+export function _setBeforeDispositionCacheRefreshForTests(hook) {
+    beforeDispositionCacheRefreshForTests = hook;
+}
+export function _setDispositionStatForTests(statSync) {
+    dispositionStatSync = statSync ?? fs.statSync;
+}
 function readState(cwd) {
     const p = statePath(cwd);
     let stat;
     try {
-        stat = fs.statSync(p);
+        stat = dispositionStatSync(p);
     }
     catch {
         if (stateCache && stateCache.path === p && stateCache.missing) {
@@ -188,6 +204,17 @@ function readState(cwd) {
     };
     return state;
 }
+function deserializeState(contents) {
+    try {
+        const parsed = JSON.parse(contents ?? "");
+        return parsed && typeof parsed === "object"
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
 // Atomic tmp+rename via clients/atomic-write.ts (#762; shared with
 // instance-registry.ts / recent-touches.ts / review-graph/builder.ts): a
 // cross-process reader must never observe a partially-written file —
@@ -198,10 +225,7 @@ function readState(cwd) {
 // failure still propagates (matches the pre-atomic writeFileSync's behavior,
 // which never swallowed errors either) — a disposition mark silently vanishing
 // is a correctness bug for this store, not just a lost observability sample.
-function writeState(cwd, state) {
-    const p = statePath(cwd);
-    fs.mkdirSync(path.dirname(p), { recursive: true });
-    writeFileAtomic(p, JSON.stringify(state, null, 2), { bestEffort: false });
+function refreshStateCache(p, state) {
     // Refresh the cache from the write we just did instead of invalidating it —
     // avoids an immediate re-stat+re-parse of the file we already have in hand,
     // and guards against coarse filesystem mtime granularity making a
@@ -215,6 +239,33 @@ function writeState(cwd, state) {
         state,
     };
 }
+function commitDisposition(cwd, anchor, entry) {
+    const p = statePath(cwd);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    const hook = beforeDispositionCommitForTests;
+    beforeDispositionCommitForTests = null;
+    hook?.();
+    commitDurableStore({
+        path: p,
+        deserialize: deserializeState,
+        merge: (state) => {
+            state.dispositions ??= {};
+            state.dispositions[anchor] = entry;
+            return state;
+        },
+        serialize: (state) => JSON.stringify(state, null, 2),
+        waitMs: DISPOSITION_LOCK_WAIT_MS,
+        retryMs: DISPOSITION_LOCK_RETRY_MS,
+        timeoutMessage: "timed out acquiring diagnostic disposition store lock",
+        onContention: "throw",
+        afterWriteLocked: (state) => {
+            const cacheHook = beforeDispositionCacheRefreshForTests;
+            beforeDispositionCacheRefreshForTests = null;
+            cacheHook?.();
+            refreshStateCache(p, state);
+        },
+    });
+}
 /** Test-only escape hatch — the state cache is module-level, so tests that
  * write the store file out-of-band (or across separate cwds sharing a stat
  * coincidence) need to reset it between cases. */
@@ -274,19 +325,17 @@ export function markDisposition(cwd, target, disposition, reason) {
     // entry can already exist at the same weak anchor (a prior flagged/suppress
     // mark) — the log should record what this mark shadowed either way.
     const existing = readState(cwd).dispositions?.[anchor];
-    emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing);
     if (disposition === "defer") {
         deferredThisSession.add(anchor);
+        emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing);
         return anchor;
     }
-    const state = readState(cwd);
-    state.dispositions ??= {};
     const now = new Date().toISOString();
     const capturesFixContext = disposition === "flagged";
     const lineText = capturesFixContext
         ? (target.content?.split(/\r?\n/)[target.line !== undefined ? target.line - 1 : -1] ?? existing?.lineText)?.trim()
         : existing?.lineText;
-    state.dispositions[anchor] = {
+    const entry = {
         disposition,
         reason: reason ?? existing?.reason,
         createdAt: existing?.createdAt ?? now,
@@ -294,7 +343,8 @@ export function markDisposition(cwd, target, disposition, reason) {
         line: capturesFixContext ? (target.line ?? existing?.line) : existing?.line,
         lineText,
     };
-    writeState(cwd, state);
+    commitDisposition(cwd, anchor, entry);
+    emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing);
     return anchor;
 }
 export function getDisposition(cwd, anchor) {

package/node_modules/pi-lens/dist/clients/diagnostics-publish.js

@@ -61,12 +61,13 @@
  */
 import { logBusEvent } from "./bus-events-logger.js";
 import { normalizeFilePath } from "./path-utils.js";
+import { createLiveBusEmitter, recordStaleBusFailure, } from "./live-bus-emitter.js";
 import { isBusPublishEnabled } from "./bus-publish.js";
 export const BUS_DIAGNOSTICS_EVENT = "pilens:diagnostics";
 export const BUS_DIAGNOSTICS_VERSION = 1;
 /** Max diagnostics carried per file per event — aligned with the widget's own per-file storage cap (`MAX_STORED_DIAGNOSTICS_PER_FILE`, clients/widget-state.ts). */
 export const MAX_DIAGNOSTICS_PER_FILE_EVENT = 12;
-let busEmit;
+const liveEmitter = createLiveBusEmitter();
 let hasLoggedFailure = false;
 let hasLoggedUnwired = false;
 let hasLoggedDisabled = false;
@@ -79,11 +80,14 @@ const reportedDirtyPaths = new Set();
  * producers share the identical `pi.events.emit` binding.
  */
 export function wireDiagnosticsBusEmitter(emitFn) {
-    busEmit = emitFn;
+    liveEmitter.wire(emitFn);
+}
+export function wireDiagnosticsBusEmitterGetter(getter) {
+    liveEmitter.wireGetter(getter);
 }
 /** Test-only: reset module state between test files. */
 export function _resetDiagnosticsPublishForTests() {
-    busEmit = undefined;
+    liveEmitter.reset();
     hasLoggedFailure = false;
     hasLoggedUnwired = false;
     hasLoggedDisabled = false;
@@ -145,6 +149,7 @@ export function publishDiagnostics(args) {
         }
         return;
     }
+    const busEmit = liveEmitter.get();
     if (!busEmit) {
         if (!hasLoggedUnwired) {
             hasLoggedUnwired = true;
@@ -184,6 +189,7 @@ export function publishDiagnostics(args) {
             files: fileEntries,
         };
         busEmit(BUS_DIAGNOSTICS_EVENT, payload);
+        hasLoggedFailure = false;
         logBusEvent({
             event: BUS_DIAGNOSTICS_EVENT,
             outcome: "emitted",
@@ -201,6 +207,7 @@ export function publishDiagnostics(args) {
         });
         if (!hasLoggedFailure) {
             hasLoggedFailure = true;
+            recordStaleBusFailure(BUS_DIAGNOSTICS_EVENT, err);
             args.dbg?.(`diagnostics-publish: pilens:diagnostics emit failed (further failures suppressed): ${err}`);
         }
     }

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

@@ -13,6 +13,7 @@
  * - OutputSemantic: How to display (blocking, warning, silent, etc.)
  * - BaselineStore: Track pre-existing issues for delta mode
  */
+import { logExtension } from "../extension-log.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { recordRunner } from "../widget-state.js";
@@ -32,6 +33,7 @@ import { applyDispositions } from "../diagnostic-dispositions.js";
 import { applyInlineSuppressions } from "./inline-suppressions.js";
 import { getToolPlan } from "./plan.js";
 import { resolveRunnerPath } from "./runner-context.js";
+import { applyRulePolicy, rulePolicyMapFromConfig } from "./rule-policy.js";
 import { getToolProfile } from "./tool-profile.js";
 import { formatDiagnostics } from "./utils/format-utils.js";
 // --- Runner Registry ---
@@ -122,9 +124,13 @@ function readFilePrefix(filePath, maxBytes = 4096) {
         }
     }
 }
-export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, modifiedRanges) {
+export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, modifiedRanges, 
+/** Authoritative workspace root; `cwd` may be a nested language root. */
+projectRoot, 
+/** Ordered per-file pipeline token, when this is a post-write dispatch. */
+writeIndex) {
     const absoluteFilePath = resolveRunnerPath(cwd, filePath);
-    const normalizedProjectRoot = normalizeMapKey(path.resolve(cwd));
+    const normalizedProjectRoot = normalizeMapKey(path.resolve(projectRoot ?? cwd));
     const normalizedCwd = normalizeMapKey(resolveLanguageRootForFile(absoluteFilePath, cwd));
     const normalizedFilePath = normalizeMapKey(absoluteFilePath);
     const kind = detectFileKind(normalizedFilePath);
@@ -143,11 +149,18 @@ export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, mo
         projectConfig,
         blockingOnly,
         modifiedRanges,
+        writeIndex,
         async hasTool(command) {
             return checkToolAvailability(command, facts);
         },
         log(message) {
-            console.error(`[dispatch] ${message}`);
+            // #1333: pi owns the terminal — a runner advisory must never be a raw
+            // write. Every DispatchContext.log line lands in extension.log instead.
+            logExtension({
+                subsystem: "dispatch",
+                message,
+                metadata: { filePath: normalizedFilePath, kind },
+            });
         },
     };
 }
@@ -493,7 +506,7 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
                 }
                 : undefined,
         });
-        recordRunner(ctx.filePath, runnerId, result.status, result.diagnostics.length, duration);
+        recordRunner(ctx.filePath, runnerId, result.status, result.diagnostics.length, duration, ctx.writeIndex);
         diagnostics.push(...result.diagnostics);
         const resultSemantic = result.semantic ?? semantic;
         if ((resultSemantic === "blocking" && result.diagnostics.length > 0) ||
@@ -563,26 +576,56 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
     // Apply delta mode ONCE across the full diagnostic set.
     // This avoids partial-baseline corruption when processing multiple groups.
     const dedupedDiagnostics = dedupeOverlappingDiagnostics(allDiagnostics);
-    const dockerOverlapSuppressed = suppressTrivyConfigDockerOverlap(dedupedDiagnostics);
-    const overlapSuppressed = suppressLintOverlapsWithLsp(dockerOverlapSuppressed);
     const fileContent = ctx.facts.getFileFact(ctx.filePath, "file.content") ?? "";
-    const inlineSuppressed = applyInlineSuppressions(overlapSuppressed, fileContent);
-    // #690: agent/user disposition layer — drop false-positive/suppress marks
-    // and anything deferred this session. flagged marks are left in place;
-    // lens_diagnostics tags them at render time via the same anchor.
+    // Project rule policy (`.pi-lens.json` `rules.<id>.disable`/`select`).
+    //
+    // Resolved from `ctx.projectRoot` (falling back to `ctx.cwd`), NOT
+    // `ctx.projectConfig` — `ctx.projectConfig` is loaded from the nested
+    // LANGUAGE root (`resolveLanguageRootForFile`), so in a monorepo where a
+    // package directory has its own `.pi-lens.json`, `discoverPiLensProjectConfig`'s
+    // upward walk stops there and never sees a repo-root policy.
+    // `lens_diagnostics` loads its policy map from `runtime.projectRoot`; using
+    // the same root here keeps the two surfaces in agreement. `ctx.projectConfig`
+    // itself is untouched — thresholds and mutation flags keep their existing
+    // language-root resolution.
+    const rulePolicy = rulePolicyMapFromConfig(loadPiLensProjectConfig(ctx.projectRoot ?? ctx.cwd).rules);
+    // The output-only filter pipeline: LSP/docker overlap suppression + inline
+    // `pi-lens-ignore` + agent/user dispositions + project rule policy. Applied
+    // AFTER dedupe so the pi renderer, widget, and delta all see one filtered
+    // set. #690: dispositions drop false-positive/suppress marks and anything
+    // deferred this session (flagged marks stay; lens_diagnostics tags them at
+    // render time). #1030: the disposition anchor + store MUST key off the
+    // PROJECT ROOT, not ctx.cwd — the mark tool writes dispositions under
+    // runtime.projectRoot, so reading from ctx.cwd (the nested language root in
+    // a monorepo) opened a different diagnostic-dispositions.json and silently
+    // no-op'd every mark under a nested marker.
     //
-    // #1030: anchor + store MUST key off the PROJECT ROOT, not ctx.cwd. In a
-    // monorepo ctx.cwd is the nested language root (resolveLanguageRootForFile,
-    // used for tool/config resolution), but the mark tool writes dispositions
-    // under runtime.projectRoot. Keying the read on ctx.cwd computed a different
-    // anchor AND opened a different diagnostic-dispositions.json (getProjectDataDir
-    // is keyed on cwd), so every false-positive/flagged/defer on a file under a
-    // nested marker silently no-op'd. Read from the project root to match the write.
-    const dispositionFiltered = applyDispositions(inlineSuppressed, ctx.projectRoot ?? ctx.cwd, ctx.filePath, fileContent);
-    let visibleDiagnostics = dispositionFiltered;
+    // #1087: "silencing is not fixing" applies to the WHOLE class, not just the
+    // policy member. This single pipeline is applied identically to the live set
+    // AND (below) to the delta baseline, so a finding persistently dropped by
+    // ANY layer — overlap, inline suppression, disposition, or policy — is
+    // absent from both sides of the delta and never oscillates into `fixed`
+    // (which `trackAgentFixed` would otherwise inflate forever). The stored
+    // baseline remains the unfiltered `dedupedDiagnostics`, so editing a
+    // project's policy/suppressions never resets or corrupts the user-authored
+    // delta baseline — the filtering is re-derived on read for both sides.
+    const applyOutputFilters = (diags) => {
+        const dockerOverlap = suppressTrivyConfigDockerOverlap(diags);
+        const overlap = suppressLintOverlapsWithLsp(dockerOverlap);
+        const inline = applyInlineSuppressions(overlap, fileContent);
+        const disposition = applyDispositions(inline, ctx.projectRoot ?? ctx.cwd, ctx.filePath, fileContent);
+        return applyRulePolicy(disposition, rulePolicy);
+    };
+    let visibleDiagnostics = applyOutputFilters(dedupedDiagnostics);
     let resolvedCount = 0;
     if (ctx.deltaMode && previousBaseline) {
-        const filtered = filterDelta(visibleDiagnostics, previousBaseline, (d) => d.id);
+        // Silencing a rule is not fixing it. The stored baseline is deliberately
+        // unfiltered (below), so compare against a fully-filtered view of it
+        // through the SAME pipeline — otherwise every persistently-suppressed
+        // finding sits in `fixed` on every dispatch and inflates the agent's
+        // resolved tally (trackAgentFixed) forever. Only `fixed` changes:
+        // filtered-out ids are absent from `after` either way.
+        const filtered = filterDelta(visibleDiagnostics, applyOutputFilters(previousBaseline), (d) => d.id);
         visibleDiagnostics = promoteDeltaUnusedToBlockers(filtered.new);
         resolvedCount = filtered.fixed.length;
     }

package/node_modules/pi-lens/dist/clients/dispatch/facts/function-facts.js

@@ -1,3 +1,4 @@
+import { isJstsFactFile } from "../../file-kinds.js";
 import { findOwnerName } from "../../symbol-containment.js";
 import { extractFactsFromTree, firstChildOfType, walk, } from "./tree-sitter-facts.js";
 const BOUNDARY_PREFIXES = [
@@ -56,12 +57,26 @@ function getParameters(node) {
     if (!fp)
         return [];
     return (fp.children ?? []).filter((c) => c &&
-        (c.type === "required_parameter" ||
+        (c.type === "identifier" ||
+            c.type === "required_parameter" ||
             c.type === "optional_parameter" ||
-            c.type === "rest_pattern"));
+            c.type === "rest_pattern" ||
+            c.type === "assignment_pattern" ||
+            // Plain JavaScript's grammar places a top-level destructured
+            // parameter directly as an object_pattern/array_pattern child
+            // of formal_parameters — no required_parameter wrapper (the TS
+            // grammar always wraps every parameter, destructured or not,
+            // which is why the wrapper types above already covered TS).
+            // Without this, `function f({a, b})` counted 0 params in JS
+            // while the TS-annotated equivalent counted correctly (#1089 P3-4).
+            c.type === "object_pattern" ||
+            c.type === "array_pattern"));
 }
 function parameterName(param) {
-    return firstNamedChild(param)?.text ?? "";
+    // JavaScript's grammar keeps a leaf parameter as the identifier itself;
+    // there is no named child to unwrap. TypeScript parameter wrapper nodes still
+    // use their first named child (type annotation/default/rest target).
+    return param.type === "identifier" ? param.text : firstNamedChild(param)?.text ?? "";
 }
 function getFunctionName(node) {
     if (node.type === "function_declaration") {
@@ -254,10 +269,10 @@ function hasReturnAwaitCall(node) {
 }
 export const functionFactProvider = {
     id: "fact.file.functions",
-    provides: ["file.functionSummaries"],
+    provides: ["file.functionSummaries", "file.functionFactsCoverage"],
     requires: ["file.content"],
     appliesTo(ctx) {
-        return /\.tsx?$/.test(ctx.filePath);
+        return isJstsFactFile(ctx.filePath);
     },
     async run(ctx, store) {
         await extractFactsFromTree(ctx, store, { "file.functionSummaries": [] }, (root) => {
@@ -309,7 +324,8 @@ export const functionFactProvider = {
                     addSummary(node);
                 if (node.type === "class_declaration" ||
                     node.type === "interface_declaration") {
-                    const nameNode = firstChildOfType(node, "type_identifier");
+                    const nameNode = firstChildOfType(node, "type_identifier") ??
+                        firstChildOfType(node, "identifier");
                     if (nameNode) {
                         containers.push({
                             name: nameNode.text,
@@ -325,6 +341,6 @@ export const functionFactProvider = {
                     summary.owner = owner;
             }
             return { "file.functionSummaries": summaries };
-        });
+        }, "file.functionFactsCoverage");
     },
 };

package/node_modules/pi-lens/dist/clients/dispatch/facts/import-facts.js

@@ -1,18 +1,6 @@
 import { logLatency } from "../../latency-logger.js";
+import { isJstsFactFile } from "../../file-kinds.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.
-const JSTS_EXTS = new Set([
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-]);
 function stripQuotes(raw) {
     return raw.replace(/^["'`]+|["'`]+$/g, "");
 }
@@ -78,19 +66,19 @@ function parseReExport(node) {
 }
 export const importFactProvider = {
     id: "fact.file.imports",
-    provides: ["file.imports", "file.reexports"],
+    provides: ["file.imports", "file.reexports", "file.importFactsCoverage"],
     requires: ["file.content"],
     appliesTo(ctx) {
-        const ext = ctx.filePath.slice(ctx.filePath.lastIndexOf(".")).toLowerCase();
-        return JSTS_EXTS.has(ext);
+        return isJstsFactFile(ctx.filePath);
     },
     async run(ctx, store) {
         const content = store.getFileFact(ctx.filePath, "file.content");
-        const setEmpty = () => {
+        const setEmpty = (complete = false) => {
             store.setFileFact(ctx.filePath, "file.imports", []);
             store.setFileFact(ctx.filePath, "file.reexports", []);
+            store.setFileFact(ctx.filePath, "file.importFactsCoverage", complete ? "complete" : "unavailable");
         };
-        if (!content) {
+        if (content == null) {
             setEmpty();
             return;
         }
@@ -205,5 +193,7 @@ export const importFactProvider = {
         });
         if (!parsed.parsed)
             setEmpty();
+        else
+            store.setFileFact(ctx.filePath, "file.importFactsCoverage", "complete");
     },
 };

package/node_modules/pi-lens/dist/clients/dispatch/facts/tree-sitter-facts.js

@@ -17,15 +17,18 @@ export const withFactTree = withTreeSitterRoot;
  * (there is no typescript-compiler fallback by design, #402). Centralising this
  * keeps each provider to just its extraction logic (and de-duplicates the prologue).
  */
-export async function extractFactsFromTree(ctx, store, defaults, extract) {
-    const writeAll = (facts) => {
+export async function extractFactsFromTree(ctx, store, defaults, extract, coverageFact) {
+    const writeAll = (facts, complete) => {
         for (const key of Object.keys(defaults)) {
             store.setFileFact(ctx.filePath, key, facts[key] ?? defaults[key]);
         }
+        if (coverageFact) {
+            store.setFileFact(ctx.filePath, coverageFact, complete ? "complete" : "unavailable");
+        }
     };
     const content = store.getFileFact(ctx.filePath, "file.content");
-    if (!content)
-        return writeAll(defaults);
+    if (content == null)
+        return writeAll(defaults, false);
     const parsed = await withFactTree(ctx.filePath, content, (root) => extract(root, content));
-    writeAll(parsed.parsed ? parsed.value : defaults);
+    writeAll(parsed.parsed ? parsed.value : defaults, parsed.parsed);
 }

package/node_modules/pi-lens/dist/clients/dispatch/indent-detect.js

@@ -0,0 +1,35 @@
+const DEFAULT_INDENTATION = { style: "space", width: 2 };
+/**
+ * Infer the prevailing indentation convention from lines that are indented.
+ * The detector deliberately has no language knowledge: formatter callers use
+ * it only as a conservative fallback when the repository has no config.
+ */
+export function detectIndentation(content) {
+    const lines = content.split(/\r?\n/);
+    const tabs = lines.filter((line) => /^\t+\S/.test(line)).length;
+    const spaceCounts = lines
+        .map((line) => line.match(/^ +(?=\S)/)?.[0].length ?? 0)
+        .filter((count) => count > 0);
+    if (tabs === 0 && spaceCounts.length === 0)
+        return DEFAULT_INDENTATION;
+    if (tabs > spaceCounts.length)
+        return { style: "tab", width: 1 };
+    if (spaceCounts.length > tabs) {
+        const counts = new Map();
+        for (const count of spaceCounts) {
+            for (const other of spaceCounts) {
+                if (other > count) {
+                    const delta = other - count;
+                    counts.set(delta, (counts.get(delta) ?? 0) + 1);
+                }
+            }
+        }
+        const inferredWidth = [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0] - b[0])[0]?.[0] ?? Math.min(...spaceCounts);
+        return { style: "space", width: inferredWidth <= 8 ? inferredWidth : 2 };
+    }
+    return DEFAULT_INDENTATION;
+}
+/** Whether the content supplied evidence from which a style can be inferred. */
+export function hasDetectableIndentation(content) {
+    return /^(?:\t+| {1,})\S/m.test(content);
+}

package/node_modules/pi-lens/dist/clients/dispatch/inline-suppressions.js

@@ -9,17 +9,17 @@
  * (Python/Ruby/…), comma-separated for multiple rules, on the same line as the
  * diagnostic or the line immediately above it.
  */
+import { normalizeRuleId } from "./rule-id-normalize.js";
 const SUPPRESS_RE = /(?:\/\/|#)\s*pi-lens-ignore:\s*(.+)/;
 /**
  * Normalize a rule id to the form a user writes in a `pi-lens-ignore` comment.
  * The napi scan and the ast-grep LSP tag the same rule as `ast-grep:<id>` /
- * `<id>-js` in some surfaces (see `normalizeRuleForDedup` in lens-diagnostics);
+ * `<id>-js` in some surfaces (see the dedup key in lens-diagnostics);
  * a user's bare `<id>` must still suppress those, so we match the normalized form
- * as well as the raw one.
+ * as well as the raw one. Shared via `rule-id-normalize.ts` so the inline
+ * suppression parser and the project rule policy matcher apply the same
+ * normalization.
  */
-function normalizeSuppressRule(ruleId) {
-    return ruleId.replace(/^ast-grep:/, "").replace(/-js$/, "");
-}
 /**
  * Drop diagnostics suppressed by an inline `pi-lens-ignore: <rule[,rule2]>`
  * comment in `content` (the file the diagnostics belong to). A diagnostic is
@@ -44,8 +44,17 @@ export function applyInlineSuppressions(diagnostics, content) {
         const suppressedLine = i + 1; // same line (1-based)
         const nextLine = i + 2; // next line (1-based)
         for (const ruleId of rules) {
-            suppressed.add(`${suppressedLine}:${ruleId}`);
-            suppressed.add(`${nextLine}:${ruleId}`);
+            // #1087: normalize the COMMENT token too, not just the diagnostic id.
+            // The diagnostic side below matches raw OR normalized, so storing only
+            // the raw comment token made `// pi-lens-ignore: no-eval-js` fail to
+            // suppress a finding surfaced under the normalized `no-eval`, while the
+            // identical `disable: ["no-eval-js"]` config key worked (rule-policy
+            // normalizes both sides). Add the normalized form so the two suppression
+            // surfaces stay symmetric.
+            for (const key of new Set([ruleId, normalizeRuleId(ruleId)])) {
+                suppressed.add(`${suppressedLine}:${key}`);
+                suppressed.add(`${nextLine}:${key}`);
+            }
         }
     }
     if (suppressed.size === 0)
@@ -55,7 +64,7 @@ export function applyInlineSuppressions(diagnostics, content) {
         const line = d.line ?? 1;
         if (suppressed.has(`${line}:${rawId}`))
             return false;
-        const normId = normalizeSuppressRule(rawId);
+        const normId = normalizeRuleId(rawId);
         return normId === rawId || !suppressed.has(`${line}:${normId}`);
     });
 }