pi-lens 3.8.70 → 3.8.72

package/dist/clients/cache-manager.js

@@ -11,6 +11,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getProjectDataDir } from "./file-utils.js";
+import { readJsonCache } from "./json-cache-read.js";
 import { normalizeMapKey } from "./path-utils.js";
 // --- Defaults ---
 const DEFAULT_MAX_AGE_MS = 30 * 60 * 1000; // 30 minutes
@@ -72,13 +73,20 @@ export class CacheManager {
             return null;
         }
         try {
-            const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+            const onReadError = (err) => {
+                this.log(`Cache read error: ${scanner} — ${err}`);
+            };
+            const meta = readJsonCache(metaPath, (parsed) => parsed, onReadError);
+            if (meta === undefined)
+                return null;
             const age = Date.now() - new Date(meta.timestamp).getTime();
             if (age > maxAgeMs) {
                 this.log(`Cache stale: ${scanner} (age: ${Math.round(age / 1000)}s, max: ${maxAgeMs / 1000}s)`);
                 return null;
             }
-            const data = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+            const data = readJsonCache(cachePath, (parsed) => parsed, onReadError);
+            if (data === undefined)
+                return null;
             this.log(`Cache hit: ${scanner} (age: ${Math.round(age / 1000)}s)`);
             return { data, meta };
         }
@@ -111,7 +119,9 @@ export class CacheManager {
         if (!fs.existsSync(metaPath))
             return false;
         try {
-            const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+            const meta = readJsonCache(metaPath, (parsed) => parsed);
+            if (meta === undefined)
+                return false;
             const age = Date.now() - new Date(meta.timestamp).getTime();
             return age <= maxAgeMs;
         }
@@ -150,16 +160,12 @@ export class CacheManager {
                 lastUpdated: new Date().toISOString(),
             };
         }
-        try {
-            return JSON.parse(fs.readFileSync(statePath, "utf-8"));
-        }
-        catch {
-            return {
-                ...DEFAULT_TURN_STATE,
-                files: {},
-                lastUpdated: new Date().toISOString(),
-            };
-        }
+        const state = readJsonCache(statePath, (parsed) => parsed);
+        return (state ?? {
+            ...DEFAULT_TURN_STATE,
+            files: {},
+            lastUpdated: new Date().toISOString(),
+        });
     }
     /**
      * Write turn state.

package/dist/clients/config-enabled-shape.js

@@ -0,0 +1,39 @@
+/**
+ * Shared parser for the `{ enabled?: boolean }` shape used by BOTH the global
+ * config (`clients/lens-config.ts`, `~/.pi-lens/config.json`) and the project
+ * config (`clients/project-lens-config.ts`, `.pi-lens.json`) for their
+ * mutation-control keys (`format`, `autofix`, `actionableWarnings.autoFix`).
+ *
+ * Extracted (#792) so both loaders parse and warn on the identical shape
+ * identically instead of two independent hand-rolled implementations that had
+ * diverged in strictness — project warned on invalid `enabled` values via its
+ * own `warnInvalidConfigOnce`, global silently dropped them. This module has
+ * no dependency on either config module (avoids an import cycle) — callers
+ * supply their own `warnInvalid` callback so each config keeps its own
+ * warn-once plumbing (keyed by its own config path).
+ */
+/**
+ * Parse a raw `{ enabled?: boolean }` value.
+ *
+ * - `undefined` input → `undefined` (key absent from the config).
+ * - Non-object (or array) input → `warnInvalid` is called, returns `undefined`.
+ * - Object with no `enabled` key → `{}` (present but nothing to say).
+ * - `enabled` present but not a boolean → `warnInvalid` is called, returns `{}`.
+ * - `enabled` a boolean → `{ enabled }`.
+ */
+export function parseEnabledShape(value, fieldPath, warnInvalid) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        warnInvalid(`${fieldPath} must be an object`);
+        return undefined;
+    }
+    const raw = value;
+    if (!("enabled" in raw))
+        return {};
+    if (typeof raw.enabled !== "boolean") {
+        warnInvalid(`${fieldPath}.enabled must be a boolean`);
+        return {};
+    }
+    return { enabled: raw.enabled };
+}

package/dist/clients/diagnostic-dispositions.js

@@ -0,0 +1,360 @@
+/**
+ * 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 { writeFileAtomic } from "./atomic-write.js";
+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();
+/** Exported (#802) so lens-diagnostic-mark's cross-check against live widget
+ * diagnostics matches a message the same way anchor derivation does — a
+ * second, slightly different normalizer would make a real match invisible. */
+export 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 {
+        // Now that writeState is tmp+rename atomic, a torn read (another process
+        // mid-write) can no longer land here — this only fires on genuine
+        // corruption/wrong-shape content. Caching `{}` against this stat is still
+        // correct, not a permanent trap: any future rewrite of the file (a fix,
+        // or this process's own next writeState) changes mtime/size, which
+        // invalidates the cache below on the next readState call. Only a file
+        // that never changes again would serve empty state forever — and
+        // reparsing the same invalid bytes every hot-path call would yield the
+        // same `{}` anyway, so the cache costs nothing in that case.
+        state = {};
+    }
+    stateCache = {
+        path: p,
+        missing: false,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+        state,
+    };
+    return state;
+}
+// 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 —
+// rename() replaces the destination atomically on both POSIX and Windows
+// (libuv uses MOVEFILE_REPLACE_EXISTING), so a concurrent readState sees
+// either the old JSON or the new JSON, never a torn write that fails to
+// parse. Unlike those best-effort writers, `bestEffort: false` here means a
+// 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 });
+    // 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;
+    });
+}
+/**
+ * WEAK-anchor-only disposition filter for the "instant" (cache-only)
+ * lens_diagnostics modes (delta/all). Drops diagnostics disposed `suppress`
+ * or deferred this session — both WEAK-anchored (`file|tool|rule|message`, no
+ * line-content hash; see module doc), so this needs ZERO file I/O: it computes
+ * only the weak anchor and never touches the diagnostic's line content.
+ *
+ * `false-positive` is deliberately NOT filtered here: it is STRICT-anchored,
+ * which requires the flagged line's content to re-derive its hash, and reading
+ * every findings file just for that would defeat the instant contract of these
+ * cache-only modes. A false-positive mark still filters at the next per-edit
+ * dispatch (`dispatcher.ts`) and in `mode=full`'s merge — both of which already
+ * have file content in hand and call `applyDispositions` (the full,
+ * content-based filter). suppress/defer, being intent-level and weak-anchored,
+ * are the marks that must apply the instant a query re-serves cached findings,
+ * and they do so here without any read.
+ */
+export function applyWeakDispositions(diagnostics, cwd, filePath) {
+    if (!diagnostics.length)
+        return diagnostics;
+    const dispositions = readState(cwd).dispositions;
+    if (!dispositions && deferredThisSession.size === 0)
+        return diagnostics;
+    return diagnostics.filter((d) => {
+        const weak = computeWeakAnchor({
+            cwd,
+            filePath,
+            tool: d.tool,
+            rule: d.rule,
+            message: d.message,
+            line: d.line,
+        });
+        if (deferredThisSession.has(weak))
+            return false;
+        if (dispositions?.[weak]?.disposition === "suppress")
+            return false;
+        return true;
+    });
+}

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

@@ -17,6 +17,7 @@
  * `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";
@@ -89,6 +90,11 @@ 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,
@@ -144,7 +150,12 @@ export const AUXILIARY_LSP_PROFILES = [
  * per-file: once over budget, this session never spawns its auxiliary fleet,
  * rather than flip-flopping file to file. */
 export function enabledAuxiliaryLspServerIds(getFlag) {
-    if (shouldDegradeAuxiliaryLsp())
+    // #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)
@@ -194,7 +205,78 @@ export function isAuxiliaryDiagnosticSuppressed(d, content) {
  * 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 applyAuxiliarySuppressions(diagnostics, content) {
-    return diagnostics.filter((d) => !isAuxiliaryDiagnosticSuppressed(d, content));
+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);

package/dist/clients/dispatch/integration.js

@@ -19,7 +19,8 @@ import { fileURLToPath } from "node:url";
 import { formatCascadeNeighborDiagnostics } from "../cascade-format.js";
 import { logCascade } from "../cascade-logger.js";
 import { getDiagnosticTracker } from "../diagnostic-tracker.js";
-import { classifyCascadeWaitTier, isTierAwareCascadeEnabled, recordOutstandingCascadeTouch, } from "../lsp/cascade-tier.js";
+import { isTierAwareCascadeEnabled, recordOutstandingCascadeTouch, } from "../lsp/cascade-tier.js";
+import { classifyCascadeWaitTier } from "../lsp/wait-policy/index.js";
 import { getServersForFileWithConfig } from "../lsp/config.js";
 import { getLSPService } from "../lsp/index.js";
 import { isExternalOrVendorFile, normalizeMapKey } from "../path-utils.js";
@@ -821,7 +822,13 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 coldSnapshotPaths.push(neighborPath);
                 continue;
             }
-            const diags = convertLspDiagnostics(entry.diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath, { source: "cascade" });
+            // #692: `source: "cascade"` used to be passed here to label `rule`
+            // (`cascade:<code>`) — that override is gone (identity must come from
+            // the diagnostic's own source; see `scanOrigin`'s doc comment), and
+            // cascade neighbor diagnostics are ephemeral display-only output
+            // (never reconciled into persisted widget/dedup state), so the label
+            // had no remaining purpose and is simply dropped rather than migrated.
+            const diags = convertLspDiagnostics(entry.diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath);
             producedLspData = true;
             const durationMs = Date.now() - neighborStart;
             logCascade({
@@ -994,7 +1001,11 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
             });
             if (!rawDiags)
                 return undefined;
-            const diags = convertLspDiagnostics(rawDiags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath, { source: "cascade" });
+            // #692: `source: "cascade"` no longer overrides `rule` (see the
+            // doc comment on the sibling call above) — dropped rather than
+            // migrated to `scanOrigin` since cascade output never touches
+            // persisted widget/dedup state.
+            const diags = convertLspDiagnostics(rawDiags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath);
             const durationMs = Date.now() - neighborStart;
             // Update cache for this neighbor at the current write sequence
             if (writeSeq != null) {
@@ -1051,10 +1062,13 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                     error: String(result.reason),
                 });
                 const entry = allDiags.get(normalizeMapKey(neighborPath));
+                // #692: `source: "cascade"` dropped (see the doc comment above the
+                // first cascade call site in this file) — no longer affects `rule`
+                // and cascade output never touches persisted widget/dedup state.
                 const diags = entry && Date.now() - entry.ts < CASCADE_TTL_MS
                     ? convertLspDiagnostics(entry.diags
                         .filter((d) => d.severity === 1)
-                        .slice(0, MAX_PER_FILE), neighborPath, { source: "cascade" })
+                        .slice(0, MAX_PER_FILE), neighborPath)
                     : [];
                 neighbors.push({
                     filePath: neighborPath,
@@ -1162,7 +1176,9 @@ function appendFallbackNeighbors(neighbors, allDiags, normalizedFileKey, cwd) {
             continue;
         if (now - ts > CASCADE_TTL_MS)
             continue;
-        const errors = convertLspDiagnostics(diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), diagPath, { source: "cascade" });
+        // #692: `source: "cascade"` dropped — see the doc comment above the
+        // first cascade `convertLspDiagnostics` call site in this file.
+        const errors = convertLspDiagnostics(diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), diagPath);
         if (errors.length === 0)
             continue;
         neighbors.push({