pi-lens 3.8.69 → 3.8.71

package/dist/clients/diagnostic-dispositions.js

@@ -0,0 +1,298 @@
+/**
+ * Agent+user disposition layer over dispatch diagnostics (#690, unifying #181/
+ * #503/#504's discussion). Four dispositions:
+ *
+ *   false-positive — the rule misfired. Project-persistent, routed nowhere
+ *                     special yet (telemetry hookup is a fast-follow).
+ *   suppress       — real finding, deliberate policy not to fix. Persistent,
+ *                     but the mechanism is an inline `pi-lens-ignore` comment
+ *                     written into the source (see suppress-writer.ts), not
+ *                     just a store entry — portable, git-visible, discoverable
+ *                     without pi-lens's own store. The store entry here is an
+ *                     audit-trail mirror, not the enforcement point.
+ *   defer          — fix later, not now. Session-ephemeral: held in memory
+ *                     only, so it naturally resurfaces on process restart —
+ *                     never persisted, never needs pruning.
+ *   flagged        — user wants the agent to fix this. Persistent until
+ *                     resolved; surfaced through the existing lens_diagnostics
+ *                     query (tagged), not a separate file/tool the agent has
+ *                     to separately poll.
+ *
+ * Anchoring: TWO flavors, chosen per-disposition because each one binds to a
+ * different thing conceptually:
+ *
+ *   STRICT ("dd:" prefix) — relativeFile|tool|rule|normalizedMessage|
+ *     lineContentHash(diagnostic's own line). Used ONLY for false-positive: a
+ *     false-positive judgment is about THIS specific piece of code — if the
+ *     line is rewritten, the rule earned a fresh chance to fire on the new
+ *     content, so the mark should NOT follow it. Reuses read-guard's
+ *     lineContentHash so a no-op formatter/whitespace pass doesn't rot the
+ *     anchor, while a semantic edit to the flagged line correctly invalidates
+ *     it.
+ *   WEAK ("ddw:" prefix) — relativeFile|tool|rule|normalizedMessage, no line
+ *     hash at all. Used for defer, flagged, and suppress: these are
+ *     intent-level judgments ("I'll get to this", "fix this", "policy says
+ *     don't") about a finding identity, not about one exact line's bytes —
+ *     they must survive incidental edits elsewhere on the flagged line
+ *     (reformatting, a nearby rename) without silently dropping the mark.
+ *     suppress's real enforcement is the inline comment (see
+ *     suppress-writer.ts) which travels with the code by construction; the
+ *     weak-anchored store entry is just an audit mirror plus a second,
+ *     belt-and-braces filter.
+ *
+ * Distinct prefixes ("dd:" vs "ddw:") keep the two id spaces from ever
+ * colliding in the same store.
+ *
+ * Content is hashed only from the diagnostic's own line (for the strict
+ * anchor), not a surrounding window as #181's original sketch considered.
+ * Two diagnostics on the same file/tool/rule/message whose flagged line
+ * happens to have identical content collide on the SAME strict anchor —
+ * deliberately: identical content at the same rule/message is a semantically
+ * equivalent finding, so marking one intentionally marks all of them (e.g. a
+ * copy-pasted line repeated a few times in the same file). If that
+ * assumption proves wrong in practice, a surrounding-window hash can be
+ * layered on later without changing the store shape.
+ */
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logDispositionEvent } from "./disposition-logger.js";
+import { publishDisposition } from "./disposition-publish.js";
+import { getProjectDataDir } from "./file-utils.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { lineContentHash } from "./read-guard.js";
+// "defer" is session-ephemeral by design (#690) — held only in memory so it
+// resurfaces for free on the next process run, with no expiry/pruning logic
+// needed. Stores WEAK anchors (see module doc) so a deferred finding stays
+// hidden all session even if the flagged line itself is edited.
+const deferredThisSession = new Set();
+function normalizeMessage(message) {
+    return message.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function relativeFile(filePath, cwd) {
+    const rel = path.relative(cwd, filePath).replace(/\\/g, "/");
+    return rel && !rel.startsWith("..") ? rel : normalizeMapKey(filePath);
+}
+/** Site-specific anchor — see module doc. Used only for false-positive. */
+export function computeStrictAnchor(args) {
+    const lines = args.content?.split(/\r?\n/);
+    const lineText = args.line !== undefined && lines ? (lines[args.line - 1] ?? "") : "";
+    const parts = [
+        relativeFile(args.filePath, args.cwd),
+        args.tool ?? "",
+        args.rule ?? "",
+        normalizeMessage(args.message),
+        lineContentHash(lineText),
+    ];
+    return `dd:${createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 12)}`;
+}
+/** Intent-level anchor — see module doc. Used for defer/flagged/suppress. */
+export function computeWeakAnchor(args) {
+    const parts = [
+        relativeFile(args.filePath, args.cwd),
+        args.tool ?? "",
+        args.rule ?? "",
+        normalizeMessage(args.message),
+    ];
+    return `ddw:${createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 12)}`;
+}
+/** Both anchors a stored/filtered diagnostic would compute — the one shared
+ * derivation both the dispatch-pipeline filter and lens-diagnostics' flagged
+ * tag lookup must use so a mark and a fresh diagnostic converge on the same
+ * ids. */
+export function anchorsForDiagnostic(cwd, filePath, diagnostic, content) {
+    const args = {
+        cwd,
+        filePath,
+        tool: diagnostic.tool,
+        rule: diagnostic.rule,
+        message: diagnostic.message,
+        line: diagnostic.line,
+        content,
+    };
+    return { strict: computeStrictAnchor(args), weak: computeWeakAnchor(args) };
+}
+function statePath(cwd) {
+    return path.join(getProjectDataDir(cwd), "cache", "diagnostic-dispositions.json");
+}
+let stateCache = null;
+function readState(cwd) {
+    const p = statePath(cwd);
+    let stat;
+    try {
+        stat = fs.statSync(p);
+    }
+    catch {
+        if (stateCache && stateCache.path === p && stateCache.missing) {
+            return stateCache.state;
+        }
+        const empty = {};
+        stateCache = { path: p, missing: true, mtimeMs: -1, size: -1, state: empty };
+        return empty;
+    }
+    if (stateCache &&
+        stateCache.path === p &&
+        !stateCache.missing &&
+        stateCache.mtimeMs === stat.mtimeMs &&
+        stateCache.size === stat.size) {
+        return stateCache.state;
+    }
+    let state;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(p, "utf-8"));
+        state =
+            parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        state = {};
+    }
+    stateCache = {
+        path: p,
+        missing: false,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+        state,
+    };
+    return state;
+}
+function writeState(cwd, state) {
+    const p = statePath(cwd);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(state, null, 2));
+    // 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
+    // read-immediately-after-write look like a cache hit on stale data.
+    const stat = fs.statSync(p);
+    stateCache = {
+        path: p,
+        missing: false,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+        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. */
+export function _resetStateCacheForTests() {
+    stateCache = null;
+}
+/** Fire-and-forget mark telemetry (see markDisposition's doc): the NDJSON log
+ * entry (project-relative path — rule-tuning data, not machine layout) and
+ * the bus event (absolute normalized path — in-process consumers navigate).
+ * Neither can throw into the mark path; both are already internally
+ * fail-safe, but the try/catch keeps a future regression in either from
+ * breaking a mark. */
+function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing) {
+    try {
+        logDispositionEvent({
+            event: "mark",
+            disposition,
+            tool: target.tool,
+            rule: target.rule,
+            filePath: relativeFile(target.filePath, cwd),
+            line: target.line,
+            reason,
+            anchor,
+            previousDisposition: existing?.disposition,
+        });
+        publishDisposition({
+            cwd,
+            filePath: target.filePath,
+            disposition,
+            tool: target.tool,
+            rule: target.rule,
+            line: target.line,
+            anchor,
+            reason,
+        });
+    }
+    catch {
+        // never let telemetry break a mark
+    }
+}
+/**
+ * Record a disposition. Picks the anchor flavor per-disposition (see module
+ * doc): strict for false-positive, weak for everything else. Returns the
+ * anchor actually used, so callers (the mark tool) can report/verify it.
+ *
+ * This is THE single choke point for mark telemetry — the NDJSON log
+ * (disposition-logger.ts, #181's FP-rule-tuning signal) and the
+ * `pilens:diagnostic:disposition` bus event (disposition-publish.ts) both
+ * hang off it, so the agent tool and any future UI caller are covered without
+ * per-caller wiring.
+ */
+export function markDisposition(cwd, target, disposition, reason) {
+    const anchor = disposition === "false-positive"
+        ? computeStrictAnchor(target)
+        : computeWeakAnchor(target);
+    // Captured for BOTH branches: a defer never writes the store, but a store
+    // 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);
+        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] = {
+        disposition,
+        reason: reason ?? existing?.reason,
+        createdAt: existing?.createdAt ?? now,
+        lastSeenAt: now,
+        line: capturesFixContext ? (target.line ?? existing?.line) : existing?.line,
+        lineText,
+    };
+    writeState(cwd, state);
+    return anchor;
+}
+export function getDisposition(cwd, anchor) {
+    return readState(cwd).dispositions?.[anchor];
+}
+export function isDeferredThisSession(anchor) {
+    return deferredThisSession.has(anchor);
+}
+/** Test-only escape hatch — defer state is module-level (one process = one
+ * session), so tests need to reset it between cases. */
+export function _resetDeferredForTests() {
+    deferredThisSession.clear();
+}
+/**
+ * Drop diagnostics disposed false-positive/suppress, or deferred this session,
+ * from `diagnostics`. `flagged` diagnostics are kept as-is — callers that want
+ * to surface the flag (e.g. lens_diagnostics' rendering) look it up separately
+ * via getDisposition on the WEAK anchor (anchorsForDiagnostic(...).weak).
+ *
+ * Computes both anchors per diagnostic (cheap — same hash primitive, twice)
+ * since false-positive is keyed strict while defer/suppress are keyed weak;
+ * see module doc for why each disposition binds the way it does.
+ */
+export function applyDispositions(diagnostics, cwd, filePath, content) {
+    if (!diagnostics.length)
+        return diagnostics;
+    const dispositions = readState(cwd).dispositions;
+    if (!dispositions && deferredThisSession.size === 0)
+        return diagnostics;
+    return diagnostics.filter((d) => {
+        const { strict, weak } = anchorsForDiagnostic(cwd, filePath, d, content);
+        if (deferredThisSession.has(weak))
+            return false;
+        if (dispositions?.[strict]?.disposition === "false-positive")
+            return false;
+        // Belt-and-braces: the inline `pi-lens-ignore` comment is the real
+        // suppress enforcement (see suppress-writer.ts) and normally already
+        // dropped this finding upstream via applyInlineSuppressions. This is a
+        // harmless second cover for the store-only audit trail case.
+        if (dispositions?.[weak]?.disposition === "suppress")
+            return false;
+        return true;
+    });
+}

package/dist/clients/diagnostics-publish.js

@@ -59,6 +59,7 @@
  * fields may be added under `v: 1`; a breaking change to an existing field's
  * meaning must bump `v`.
  */
+import { logBusEvent } from "./bus-events-logger.js";
 import { normalizeFilePath } from "./path-utils.js";
 import { isBusPublishEnabled } from "./bus-publish.js";
 export const BUS_DIAGNOSTICS_EVENT = "pilens:diagnostics";
@@ -67,6 +68,8 @@ export const BUS_DIAGNOSTICS_VERSION = 1;
 export const MAX_DIAGNOSTICS_PER_FILE_EVENT = 12;
 let busEmit;
 let hasLoggedFailure = false;
+let hasLoggedUnwired = false;
+let hasLoggedDisabled = false;
 let seqCounter = 0;
 /** Paths this producer has reported with at least one non-empty diagnostics array, so we know when to fire the one-time clean-transition event. */
 const reportedDirtyPaths = new Set();
@@ -82,6 +85,8 @@ export function wireDiagnosticsBusEmitter(emitFn) {
 export function _resetDiagnosticsPublishForTests() {
     busEmit = undefined;
     hasLoggedFailure = false;
+    hasLoggedUnwired = false;
+    hasLoggedDisabled = false;
     seqCounter = 0;
     reportedDirtyPaths.clear();
 }
@@ -129,10 +134,28 @@ export function publishDiagnostics(args) {
         return;
     if (args.files.length === 0)
         return;
-    if (!isBusPublishEnabled())
+    if (!isBusPublishEnabled()) {
+        if (!hasLoggedDisabled) {
+            hasLoggedDisabled = true;
+            logBusEvent({
+                event: BUS_DIAGNOSTICS_EVENT,
+                outcome: "skipped_disabled",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
         return;
-    if (!busEmit)
+    }
+    if (!busEmit) {
+        if (!hasLoggedUnwired) {
+            hasLoggedUnwired = true;
+            logBusEvent({
+                event: BUS_DIAGNOSTICS_EVENT,
+                outcome: "skipped_unwired",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
         return;
+    }
     try {
         const fileEntries = args.files.map((f) => {
             const normPath = normalizeFilePath(f.path);
@@ -161,8 +184,21 @@ export function publishDiagnostics(args) {
             files: fileEntries,
         };
         busEmit(BUS_DIAGNOSTICS_EVENT, payload);
+        logBusEvent({
+            event: BUS_DIAGNOSTICS_EVENT,
+            outcome: "emitted",
+            cwd: payload.cwd,
+            fileCount: payload.files.length,
+            seq: payload.seq,
+        });
     }
     catch (err) {
+        logBusEvent({
+            event: BUS_DIAGNOSTICS_EVENT,
+            outcome: "emit_failed",
+            cwd: normalizeFilePath(args.cwd),
+            error: String(err),
+        });
         if (!hasLoggedFailure) {
             hasLoggedFailure = true;
             args.dbg?.(`diagnostics-publish: pilens:diagnostics emit failed (further failures suppressed): ${err}`);

package/dist/clients/dispatch/auxiliary-lsp.js

@@ -16,6 +16,8 @@
  * Adding a new cross-cutting tool = register an `LSPServerInfo` with
  * `role:"auxiliary"` (clients/lsp/server.ts) + one profile entry here.
  */
+import { shouldDegradeAuxiliaryLsp } from "../lsp-budget.js";
+import { isSubagentSession } from "../subagent-mode.js";
 import { findLocalOpengrepConfig } from "../opengrep-config.js";
 import { findLocalTyposConfig } from "../typos-config.js";
 import { findLocalZizmorConfig } from "../zizmor-config.js";
@@ -56,6 +58,11 @@ export function isNosemgrepSuppressed(d, content) {
     return (checkLine(lines[startLine], false) ||
         checkLine(lines[startLine - 1], true));
 }
+// #277 R7: every profile below used this exact same rule (ERROR-severity
+// findings block only when the workspace opted into curated/authored rules;
+// everything else stays advisory) — shared here instead of copy-pasted per
+// profile so a future policy change (e.g. a WARNING-blocking tier) is one edit.
+const blockOnErrorWhenAllowed = (d, { blockingAllowed }) => (blockingAllowed && d.severity === 1 ? "blocking" : "warning");
 export const AUXILIARY_LSP_PROFILES = [
     {
         serverId: "opengrep",
@@ -71,7 +78,7 @@ export const AUXILIARY_LSP_PROFILES = [
         // supplies its own curated rules (the author's deliberate severity); the
         // auto set is advisory. Either way, findings surface via lens_diagnostics.
         allowBlocking: (cwd) => Boolean(findLocalOpengrepConfig(cwd)),
-        semantic: (d, { blockingAllowed }) => blockingAllowed && d.severity === 1 ? "blocking" : "warning",
+        semantic: blockOnErrorWhenAllowed,
         defectClass: (d) => classifyDefect(String(d.code ?? ""), "opengrep", d.message ?? ""),
         // Honor the canonical Semgrep suppression the user already knows (#441).
         isSuppressed: isNosemgrepSuppressed,
@@ -83,12 +90,17 @@ export const AUXILIARY_LSP_PROFILES = [
         sourceMatch: /ast[-_]?grep/i,
         killSwitchFlag: "no-ast-grep",
         enabledByDefault: true,
+        // Matches the in-process ast-grep-napi runner's own `skipTestFiles: true`
+        // (#687) — that flag stops applying the moment the ast-grep binary is
+        // present, since the napi runner then skips entirely in favor of this
+        // LSP surface, which had no test-file gating of its own.
+        skipTestFiles: true,
         // The ast-grep LSP runs either the repo's own sgconfig (when present) or
         // pi-lens's shipped baseline sgconfig. In both cases the rule severity is
         // deliberate, so preserve ast-grep's severity semantics: ERROR can block,
         // WARNING/INFO stay advisory.
         allowBlocking: () => true,
-        semantic: (d, { blockingAllowed }) => blockingAllowed && d.severity === 1 ? "blocking" : "warning",
+        semantic: blockOnErrorWhenAllowed,
         defectClass: (d) => classifyDefect(String(d.code ?? ""), "ast-grep", d.message ?? ""),
     },
     {
@@ -104,7 +116,7 @@ export const AUXILIARY_LSP_PROFILES = [
         // ignores). Advisory otherwise — findings still surface via lens_diagnostics.
         // zizmor maps High→ERROR(1), Medium/Low→WARNING(2), Informational→INFO(3).
         allowBlocking: (cwd) => Boolean(findLocalZizmorConfig(cwd)),
-        semantic: (d, { blockingAllowed }) => blockingAllowed && d.severity === 1 ? "blocking" : "warning",
+        semantic: blockOnErrorWhenAllowed,
         defectClass: (d) => classifyDefect(String(d.code ?? ""), "zizmor", d.message ?? ""),
     },
     {
@@ -122,23 +134,149 @@ export const AUXILIARY_LSP_PROFILES = [
         // severity is WARNING, so even with a config it stays advisory unless the
         // repo raises `diagnostic-severity` to Error.
         allowBlocking: (cwd) => Boolean(findLocalTyposConfig(cwd)),
-        semantic: (d, { blockingAllowed }) => blockingAllowed && d.severity === 1 ? "blocking" : "warning",
+        semantic: blockOnErrorWhenAllowed,
         // A misspelling is a documentation/quality defect — not security or
         // correctness. "style" is the closest taxonomy class.
         defectClass: () => "style",
     },
 ];
 /** The auxiliary server ids enabled for this turn (the lsp runner passes these
- *  to `touchFile` since it — not the LSP service — owns flag access). */
+ *  to `touchFile` since it — not the LSP service — owns flag access).
+ *
+ * #449 slice 2 (prototype): when this process decided at `session_start` that
+ * the machine-wide LSP budget is exceeded (`clients/lsp-budget.ts`), auxiliary
+ * servers are skipped entirely for the rest of the session — the primary
+ * language server per file is unaffected. This is a per-SESSION degrade, not
+ * per-file: once over budget, this session never spawns its auxiliary fleet,
+ * rather than flip-flopping file to file. */
 export function enabledAuxiliaryLspServerIds(getFlag) {
+    // #449 slice 2 (budget): skip auxiliaries when machine-wide LSP budget is
+    // exceeded. #713 (subagent light mode): reuse the same seam — a subagent
+    // session also skips auxiliaries; the parent session already runs them on
+    // the same cwd. PI_LENS_SUBAGENT_FULL=1 restores full behavior via
+    // isSubagentSession() returning false.
+    if (shouldDegradeAuxiliaryLsp() || isSubagentSession())
+        return [];
     return AUXILIARY_LSP_PROFILES.flatMap((p) => p.enabledByDefault &&
         !(p.killSwitchFlag && getFlag(p.killSwitchFlag) === true)
         ? [p.serverId]
         : []);
 }
+// #277 R7: `findAuxiliaryProfileForSource` is called once per diagnostic, and a
+// file's diagnostics are typically dominated by a handful of distinct `source`
+// strings (one per tool that fired). Memoizing by exact `source` turns an
+// O(profiles) regex scan per diagnostic into one scan per distinct source seen
+// — safe because `AUXILIARY_LSP_PROFILES` is a fixed module-level const, never
+// mutated at runtime, so a source's matching profile never changes.
+const profileForSourceCache = new Map();
 /** Find the profile whose server emitted a diagnostic with this `source`. */
 export function findAuxiliaryProfileForSource(source) {
     if (!source)
         return undefined;
-    return AUXILIARY_LSP_PROFILES.find((p) => p.sourceMatch.test(source));
+    const cached = profileForSourceCache.get(source);
+    if (cached !== undefined || profileForSourceCache.has(source))
+        return cached;
+    const found = AUXILIARY_LSP_PROFILES.find((p) => p.sourceMatch.test(source));
+    profileForSourceCache.set(source, found);
+    return found;
+}
+/**
+ * Single-diagnostic suppression check (#586): look up the diagnostic's
+ * auxiliary profile by `source` and, if that profile declares an
+ * `isSuppressed` callback (currently only opengrep's `# nosemgrep`, #441),
+ * apply it. Returns false for diagnostics with no matching profile or whose
+ * profile has no native suppression syntax — the common case for plain
+ * language-server diagnostics.
+ *
+ * This is the ONE lookup+apply implementation; every call site that decides
+ * whether to drop a diagnostic for its tool's own inline suppression comment
+ * should go through this (or `applyAuxiliarySuppressions` below) rather than
+ * re-deriving the profile lookup.
+ */
+export function isAuxiliaryDiagnosticSuppressed(d, content) {
+    const profile = findAuxiliaryProfileForSource(d.source);
+    return Boolean(profile?.isSuppressed?.(d, content));
+}
+/**
+ * Filter a diagnostic list down to the ones NOT suppressed by their
+ * auxiliary profile's native inline-comment syntax (#586). This is the
+ * shared helper `tools/lsp-diagnostics.ts` and `clients/lsp/index.ts`'s
+ * `runWorkspaceDiagnostics` use so a `// nosemgrep` (or any future profile's
+ * equivalent) suppresses a finding identically whether it's seen via the
+ * per-edit dispatch runner or a standalone diagnostics query — previously
+ * only the former honored it (#586).
+ *
+ * #692: `opts.fileRole` additionally drops a diagnostic whose auxiliary
+ * profile declares `skipTestFiles` (e.g. ast-grep, #687) when the file is a
+ * test file — the per-edit dispatch runner (`clients/dispatch/runners/lsp.ts`)
+ * has applied this gate since #687/#688 via its own inline check; the
+ * `runWorkspaceDiagnostics` workspace sweep (`clients/lsp/index.ts`) called
+ * this function WITHOUT ever passing a fileRole, so ast-grep findings on test
+ * files that are suppressed per-edit reappeared wholesale in every
+ * `mode=full` sweep. Omitting `opts` (or `opts.fileRole`) keeps every existing
+ * 2-arg call site's behavior byte-for-byte unchanged.
+ */
+export function applyAuxiliarySuppressions(diagnostics, content, opts) {
+    return diagnostics.filter((d) => {
+        if (isAuxiliaryDiagnosticSuppressed(d, content))
+            return false;
+        if (opts?.fileRole === "test") {
+            const profile = findAuxiliaryProfileForSource(d.source);
+            if (profile?.skipTestFiles)
+                return false;
+        }
+        return true;
+    });
+}
+/**
+ * #692: shared aux re-tag implementation — extracted from the per-edit
+ * dispatch runner (`clients/dispatch/runners/lsp.ts`) so a scan/sweep path
+ * that reconciles LSP diagnostics into widget state (`lens_diagnostics
+ * mode=full`, `lsp_diagnostics`) gives its auxiliary-sourced findings
+ * (ast-grep, opengrep, zizmor, typos) the SAME tool re-tag, semantic policy,
+ * and defect-class classification the per-edit path always has — previously
+ * only the per-edit runner ran this loop, so a scan-reconciled aux finding
+ * kept `tool: "lsp"` and lost its curated-repo-rules `blockingAllowed`
+ * context entirely (#692).
+ *
+ * `diagnostics` and `rawLspDiags` must be the SAME length and index-aligned —
+ * `convertLspDiagnostics` maps its input 1:1, so this holds for every caller
+ * that passes it the same array it just converted. Mutates and returns the
+ * SURVIVING subset of `diagnostics` (native-inline-suppressed and
+ * `skipTestFiles`-dropped entries removed), mirroring the per-edit runner's
+ * prior inline behavior exactly.
+ */
+export function retagAuxiliaryDiagnostics(diagnostics, rawLspDiags, content, ctx) {
+    const blockingAllowedByProfile = new Map();
+    const suppressedIndices = new Set();
+    for (let i = 0; i < diagnostics.length; i++) {
+        const profile = findAuxiliaryProfileForSource(rawLspDiags[i]?.source);
+        if (!profile)
+            continue;
+        if (profile.skipTestFiles && ctx.fileRole === "test") {
+            suppressedIndices.add(i);
+            continue;
+        }
+        if (isAuxiliaryDiagnosticSuppressed(rawLspDiags[i], content)) {
+            suppressedIndices.add(i);
+            continue;
+        }
+        let blockingAllowed = blockingAllowedByProfile.get(profile);
+        if (blockingAllowed === undefined) {
+            blockingAllowed = profile.allowBlocking?.(ctx.cwd) ?? false;
+            blockingAllowedByProfile.set(profile, blockingAllowed);
+        }
+        const d = diagnostics[i];
+        d.tool = profile.tool;
+        d.semantic = profile.semantic(rawLspDiags[i], { blockingAllowed });
+        if (d.semantic !== "blocking" && d.severity === "error") {
+            d.severity = "warning";
+        }
+        const defectClass = profile.defectClass?.(rawLspDiags[i]);
+        if (defectClass)
+            d.defectClass = defectClass;
+    }
+    return suppressedIndices.size
+        ? diagnostics.filter((_, i) => !suppressedIndices.has(i))
+        : diagnostics;
 }

package/dist/clients/dispatch/dispatcher.js

@@ -27,6 +27,7 @@ import { loadPiLensProjectConfig } from "../project-lens-config.js";
 import { RUNTIME_CONFIG, getRunnerTimeoutFloorMs } from "../runtime-config.js";
 import { safeSpawnAsync } from "../safe-spawn.js";
 import { classifyDiagnostic } from "./diagnostic-taxonomy.js";
+import { applyDispositions } from "../diagnostic-dispositions.js";
 import { applyInlineSuppressions } from "./inline-suppressions.js";
 import { getToolPlan } from "./plan.js";
 import { resolveRunnerPath } from "./runner-context.js";
@@ -559,7 +560,11 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
     const overlapSuppressed = suppressLintOverlapsWithLsp(dockerOverlapSuppressed);
     const fileContent = ctx.facts.getFileFact(ctx.filePath, "file.content") ?? "";
     const inlineSuppressed = applyInlineSuppressions(overlapSuppressed, fileContent);
-    let visibleDiagnostics = inlineSuppressed;
+    // #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.
+    const dispositionFiltered = applyDispositions(inlineSuppressed, ctx.cwd, ctx.filePath, fileContent);
+    let visibleDiagnostics = dispositionFiltered;
     let resolvedCount = 0;
     if (ctx.deltaMode && previousBaseline) {
         const filtered = filterDelta(visibleDiagnostics, previousBaseline, (d) => d.id);