@herbertgao/pi-extensions 2026.9.1 → 2026.9.3

package/node_modules/pi-lens/dist/tools/lens-diagnostics.js

@@ -18,6 +18,7 @@ import { DEPENDENCY_DRIFT_MAX_DELIVERIES } from "../clients/blocker-freshness.js
 import { freshnessFromMtime } from "../clients/freshness.js";
 import { applyInlineSuppressions } from "../clients/dispatch/inline-suppressions.js";
 import { gateFindingsByPathFreshness } from "../clients/advisory-provenance.js";
+import { markUnreconciledFindings } from "../clients/finding-delivery-gate.js";
 import { normalizeRuleId } from "../clients/dispatch/rule-id-normalize.js";
 import { applyRulePolicy, rulePolicyMapFromConfig, } from "../clients/dispatch/rule-policy.js";
 import { loadPiLensProjectConfig } from "../clients/project-lens-config.js";
@@ -26,7 +27,8 @@ import { combineAbortSignals } from "../clients/deadline-utils.js";
 import { getProjectIgnoreMatcher } from "../clients/file-utils.js";
 import { isAtOrAboveHomeDir, normalizeEphemeralMapKey, normalizeFilePath, } from "../clients/path-utils.js";
 import { getLSPService } from "../clients/lsp/index.js";
-import { primaryServerId } from "../clients/lsp/config.js";
+import { retireInlineBlockerAndResyncGuard } from "../clients/git-guard.js";
+import { primaryServerId, resolveLspCwdForFile, } from "../clients/lsp/config.js";
 import { getFullScanWallClockMs } from "../clients/lsp/workspace-sweep-hold.js";
 import { demoteInferredProjectSweepResults } from "../clients/lsp/inferred-project.js";
 import { hashDiagnosticContent, } from "../clients/lsp/diagnostic-binding.js";
@@ -38,11 +40,14 @@ import { generatedSkipNotice, scanTruncationNotice, } from "../clients/lens-engi
 import { scanProjectDiagnostics } from "../clients/project-diagnostics/scanner.js";
 import { classifyDiagnosticTier, getFileDiagnosticSummaries, reconcileCorrelatedScanDiagnostics, reconcileScanDiagnostics, reconcileStaleWidgetDependencyBlockers, reconcileStaleWidgetFiles, widgetDiagnosticUri, } from "../clients/widget-state.js";
 import { logLatency } from "../clients/latency-logger.js";
+import { logExtension } from "../clients/extension-log.js";
+import { recordDegradationOnce } from "../clients/degradation-ledger.js";
 import { convertLspDiagnostics } from "../clients/dispatch/utils/lsp-diagnostics.js";
 import { retagAuxiliaryDiagnostics } from "../clients/dispatch/auxiliary-lsp.js";
 import { detectFileRole } from "../clients/file-role.js";
 import { STALE_LINE_MARKER } from "../clients/stale-marker.js";
 import { makeProgressReporter, scanningSummaryLine } from "./scan-progress.js";
+import { createLspDiagnosticsTool, LSP_SEVERITY_FILTERS, MAX_BATCH_FILES, } from "./lsp-diagnostics.js";
 import { demotePastEofDiagnostics, PAST_EOF_STALE_MARKER, resyncDocumentOnPastEof, } from "../clients/diagnostic-line-freshness.js";
 // The widget state exposes the full per-file diagnostic set; this is the tool's
 // own generous display budget per file (independent of the TUI's 12 cap), to
@@ -53,7 +58,7 @@ const MAX_DIAGNOSTICS_PER_FILE = 50;
 // narrow, not paginate. Erroring (rather than silently truncating) means a
 // caller can never believe it checked files it didn't (issue's stated
 // invariant).
-const MAX_PATHS_ENTRIES = 200;
+const MAX_PATHS_ENTRIES = MAX_BATCH_FILES;
 // #1623: the reason rendered for every heavyweight-analyzer lane (gitleaks,
 // trivy, govulncheck, dead-code, knip, jscpd, madge, opengrep, test-runner)
 // when mode=full is called without refreshRunners=cheap/all/cached — the
@@ -135,35 +140,75 @@ nextWriteIndex,
 // #798/#338: capture host UI methods synchronously from the active tool event.
 // The returned closure is safe for the later async sweep to invoke because it
 // never dereferences the session-guarded ctx.ui getter.
-captureLspStatusRepaint, getRuntime) {
+captureLspStatusRepaint, getRuntime, isLensGuardEnabled = () => true) {
+    const lspProbe = createLspDiagnosticsTool(nextWriteIndex, (info) => {
+        const runtime = getRuntime?.();
+        if (!runtime)
+            return;
+        const retired = retireInlineBlockerAndResyncGuard({
+            runtime,
+            cacheManager,
+            cwd: info.cwd,
+            filePath: info.filePath,
+            ...(info.writeIndex === undefined
+                ? {}
+                : { writeIndex: info.writeIndex }),
+            coveredSources: info.coveredSources,
+            lensGuardEnabled: isLensGuardEnabled(),
+        });
+        if (retired) {
+            logExtension({
+                subsystem: "git-guard",
+                level: "debug",
+                message: `inline_blocker: retired for ${info.filePath}`,
+            });
+        }
+    }, getLspService);
     return {
         name: "lens_diagnostics",
         label: "Project Diagnostics",
-        description: "Query pi-lens's diagnostic state. mode=delta/all are cache-only and instant; " +
-            "mode=full is an expensive active project-wide LSP scan merged with cached runner state.\n\n" +
-            "IMPORTANT: unlike lsp_diagnostics (LSP only), this tool covers ALL dispatch " +
-            "runners: LSP errors, tree-sitter structural rules, ast-grep security rules, " +
-            "biome/ruff/eslint lint findings, complexity violations, and more.\n\n" +
-            "mode=delta (default): all warnings for the current agent turn — fixable warnings " +
-            "(actionable-warnings cache) AND code quality/style/complexity issues " +
-            "(code-quality-warnings cache). Same scope as the turn-end advisory, current turn only.\n\n" +
-            "mode=all: blocking errors and warnings — with the actual messages (line, rule, " +
-            "text), not just counts — for every file the agent has " +
-            "EDITED this session (files that went through the dispatch pipeline). " +
-            "NOTE: unedited files with pre-existing errors do NOT appear here — this is " +
-            "not a full project scan. Use before declaring work done; stale blocking " +
-            "errors from earlier turns are visible even if they dropped from turn-end context.\n\n" +
-            "mode=full: EXPENSIVE active scan. Runs project-wide LSP diagnostics for " +
-            "all supported files (including unedited files), then merges/deduplicates " +
-            "that with mode=all cached runner state. Optional refreshRunners=cheap/all/cached " +
-            "folds in project-wide runner findings: the in-process scanners (tree-sitter + " +
-            "fact-rules + ast-grep) plus a FRESH run of the heavyweight analyzers — knip, " +
-            "jscpd (copy-paste), madge (circular deps), gitleaks (secrets), govulncheck/trivy " +
-            "(CVEs), dead-code — rather than a possibly-stale session_start cache; each " +
-            "analyzer de-dupes against a concurrent background run of itself, so this can't " +
-            "double-spawn. Bounded by the slowest analyzer (trivy's own ~180s ceiling).",
-        promptSnippet: "Use lens_diagnostics mode=all to verify no blocking errors remain; use mode=full for expensive project-wide checks",
+        description: 'Query pi-lens diagnostics from the session cache or an active LSP probe, at paths or workspace scope. Empty cache is not proof of clean; probe changed paths when findings are absent or stale. Example: `{source: "lsp", scope: "paths", paths: ["src/app.ts"]}`.',
+        promptSnippet: "lens_diagnostics source=session reads the session cache and an empty cache is not proof of a clean file; use source=lsp scope=paths for changed files when cached findings are absent or stale",
         renderResult: compactRenderResult(({ details, args, isError, text }) => {
+            if (details?.source === "lsp") {
+                const count = details.totalDiagnostics ?? 0;
+                const files = details.filesChecked ?? details.filesScanned ?? 0;
+                const noun = count === 1 ? "diagnostic" : "diagnostics";
+                const filePath = typeof details?.filePath === "string"
+                    ? details.filePath
+                    : Array.isArray(args?.paths) &&
+                        args.paths.length === 1 &&
+                        typeof args.paths[0] === "string"
+                        ? args.paths[0]
+                        : undefined;
+                const singleFile = (details?.mode === "file" || files === 1) &&
+                    typeof filePath === "string"
+                    ? ` ${path.basename(filePath)}`
+                    : "";
+                const scope = files > 1 ? ` across ${files} files` : singleFile;
+                if (isError)
+                    return `lens_diagnostics lsp — ${text.split("\n")[0] ?? "error"}`;
+                if ((details.navigationOnlyFiles ?? 0) > 0)
+                    return `lens_diagnostics${scope} — ${count} ${noun} · ${details.cleanFiles ?? 0} clean · ${details.navigationOnlyFiles} navigation-only`;
+                if ((details.unconfirmedFiles ?? 0) > 0)
+                    return `lens_diagnostics${scope} — ${count} ${noun} · ${details.cleanFiles ?? 0} clean · ${details.unconfirmedFiles} unconfirmed${details.timedOutFiles ? ` (${details.timedOutFiles} timed out)` : ""}`;
+                const outcomeCounts = details.outcomeCounts;
+                const notConfirmed = outcomeCounts
+                    ? (outcomeCounts.inconclusive ?? 0) +
+                        (outcomeCounts.unavailable ?? 0) +
+                        (outcomeCounts.unsupported ?? 0) +
+                        (outcomeCounts.failed ?? 0)
+                    : 0;
+                if (notConfirmed > 0)
+                    return `lens_diagnostics${scope} — ${count} ${noun} · ${notConfirmed} checks not confirmed`;
+                if ((details.incompleteFiles ?? 0) > 0)
+                    return `lens_diagnostics${scope} — incomplete (${details.incompleteFiles} files not confirmed)`;
+                if (count === 0 && details.unconfirmed)
+                    return details.timedOut
+                        ? `lens_diagnostics${scope} — timed out (result may be incomplete)`
+                        : `lens_diagnostics${scope} — unconfirmed (server cannot confirm clean)`;
+                return `lens_diagnostics${scope} — ${count} ${noun}`;
+            }
             // Streaming progress partials render the live bar (see scanningSummaryLine)
             // instead of the details-driven summary, which would show "0 diagnostics"
             // mid-scan.
@@ -222,54 +267,124 @@ captureLspStatusRepaint, getRuntime) {
             return `lens_diagnostics ${mode} — ${parts.join(" · ")} (${files} files)${coldSuffix}${failedSuffix}`;
         }),
         parameters: Type.Object({
+            source: Type.Optional(Type.String({
+                enum: ["session", "lsp"],
+                description: "Evidence source: session cache (empty cache is not proof of a " +
+                    "clean file — use source=lsp for changed files) or an active LSP probe.",
+            })),
+            scope: Type.Optional(Type.String({
+                enum: ["paths", "workspace"],
+                description: 
+                // #2860: no schema value maps to "current turn's delta" — the
+                // default (omitted scope) already gives that for
+                // source=session, and for source=lsp `delta` was byte-identical
+                // to `paths` (round-2 verify N/F4), so exposing it would only
+                // invite a caller to believe it does something distinct.
+                "Coverage scope: explicit paths, or workspace (default: current turn's delta for source=session).",
+            })),
             mode: Type.Optional(Type.String({
                 enum: ["delta", "all", "full"],
-                description: "delta = current turn's fixable warnings (default). " +
-                    "all = session diagnostics for edited/dispatched files. " +
-                    "full = expensive active project-wide LSP scan plus cached runner diagnostics.",
+                description: "delta = current turn; all = cache-only; full = active LSP scan of paths. Empty cache is not proof of clean.",
+            })),
+            path: Type.Optional(Type.String({
+                description: "One file or directory for source=lsp checks.",
+            })),
+            concurrency: Type.Optional(Type.Number({
+                description: "Source=lsp batch concurrency (maximum 16).",
+            })),
+            waitMs: Type.Optional(Type.Number({
+                description: "Source=lsp per-file wait budget in milliseconds.",
+            })),
+            serverScope: Type.Optional(Type.String({
+                enum: ["primary", "all"],
+                description: "Source=lsp server coverage: primary or all.",
             })),
             refreshRunners: Type.Optional(Type.Union([
                 Type.Boolean(),
                 Type.String({ enum: ["cached", "cheap", "all", "none"] }),
             ], {
-                description: "mode=full only: false/none = LSP + widget state only. cached/cheap/all all now trigger a FRESH run (#585) of the heavyweight project analyzers (knip, jscpd, madge, gitleaks, govulncheck, trivy, dead-code) in parallel — bounded by the slowest one (trivy's own ~180s ceiling) — instead of reading a possibly-stale session_start cache; safe to relaunch since each analyzer de-dupes concurrent runs against the same project root. cheap/all additionally refresh the in-process runners (tree-sitter + fact-rules + ast-grep) first.",
+                description: "Analyzer refresh mode for full view.",
             })),
             maxProjectFiles: Type.Optional(Type.Number({
-                description: "mode=full refreshRunners=cheap/all only: cap project files scanned by the cheap project runners (tree-sitter + fact-rules + ast-grep). Does NOT bound the LSP sweep — use maxLspFiles for that.",
+                description: "Project-file limit for cheap runners.",
             })),
             maxLspFiles: Type.Optional(Type.Number({
-                description: "mode=full only: cap the number of files routed through the language server for the project-wide LSP sweep. On large projects (e.g. a Next.js app with thousands of source files) the uncapped sweep can take many minutes; set this to bound it. Default is generous (env PI_LENS_LSP_WORKSPACE_MAX_FILES, else 5000).",
+                description: "File limit for the LSP sweep.",
             })),
             includeGenerated: Type.Optional(Type.Boolean({
-                description: "mode=full refreshRunners=cheap/all only (no effect with refreshRunners=cached/none, since no project scan runs to apply it to): scan WITHOUT the generated/artifact NAME-heuristic filter (lockfiles, gen.ts-style names, generated/ dirs, …). Default false. Use when a scan's 'excluded by generated-name heuristics' notice suggests a real file was skipped.",
+                description: "Include generated-name paths in full scans.",
             })),
             severity: Type.Optional(Type.String({
-                enum: ["error", "warning", "all"],
-                description: "Filter by severity (default: all).",
+                enum: [...LSP_SEVERITY_FILTERS],
+                description: "Filter by severity threshold (default: all): error shows errors; warning includes errors and warnings; information includes errors, warnings, and information; hint and all show every known tier.",
             })),
             paths: Type.Optional(Type.Array(Type.String(), {
                 maxItems: MAX_PATHS_ENTRIES,
-                description: `Restrict any mode to an explicit file/directory list (max ${MAX_PATHS_ENTRIES} entries; ` +
-                    "more errors instead of silently truncating). Entries may be relative " +
-                    "(resolved against cwd) or absolute, and a directory entry matches all " +
-                    'files under it (e.g. "src/"). mode=delta/all are a pure post-filter ' +
-                    "of cached/session state — they can only show findings for files pi-lens " +
-                    "has already dispatched, so an unseen file shows nothing (use mode=full " +
-                    "for an active scan). mode=full actively scans exactly these paths (LSP " +
-                    "sweep + cheap in-process runners); cached heavyweight analyzers " +
-                    "(jscpd/madge/gitleaks/knip) and the project snapshot are still post-filtered " +
-                    "cache reads, never relaunched. Explicitly-listed files are NOT filtered " +
-                    "through the project ignore matcher (matching lsp_diagnostics' paths " +
-                    "semantics) — naming a file is assumed to mean it regardless of " +
-                    ".gitignore/.pi-lens.json; a directory entry's expansion still honors " +
-                    "ignore (and when the list mixes directories and files, mode=full scans " +
-                    "via the ignore-filtered walk, so an ignore-excluded file entry is only " +
-                    "guaranteed an active scan in a files-only list). Nonexistent entries " +
-                    "are skipped (mode=full notes them; useful for git-staged-file wrappers " +
-                    "where a deleted-but-staged path can appear).",
+                description: "Files or directories to filter.",
             })),
         }),
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
+            const requestedSource = params.source;
+            const requestedScope = params.scope;
+            const legacyMode = params.mode;
+            const source = requestedSource ?? "session";
+            const scope = requestedScope ??
+                (legacyMode === "delta" || legacyMode === undefined
+                    ? source === "lsp"
+                        ? "paths"
+                        : "delta"
+                    : "workspace");
+            const cwd = ctx.cwd ?? getCwd();
+            if (source === "lsp") {
+                const lspParams = { ...params };
+                delete lspParams.source;
+                delete lspParams.scope;
+                // #2860: explicit `path`/`paths` always win. `scope=workspace`
+                // only supplies a `cwd` default (a full workspace sweep) when the
+                // caller gave NEITHER — it must never override an explicit
+                // narrower request (the #2052 root-eviction hang and the
+                // SKILL.md "check a folder" recipe both depend on this: a
+                // directory `path` under scope=workspace scans that directory,
+                // not the whole project).
+                const hasExplicitPath = typeof lspParams.path === "string" && lspParams.path.length > 0;
+                const hasExplicitPaths = Array.isArray(lspParams.paths) && lspParams.paths.length > 0;
+                if (scope === "workspace" && !hasExplicitPath && !hasExplicitPaths) {
+                    lspParams.path = cwd;
+                }
+                const lspStart = Date.now();
+                const result = (await lspProbe.execute(_toolCallId, lspParams, signal, onUpdate, ctx.signal ? { cwd, signal: ctx.signal } : { cwd }));
+                // #2860 F11: the folded route's own durable trace — without this,
+                // F1's class of defect (a real LSP result rendering as "clean")
+                // leaves no record in latency.log distinguishing source=lsp from
+                // source=session. One record per tool call (not per file), same
+                // convention as the mode=all `blocker_freshness_widget_gate`
+                // phase above.
+                logLatency({
+                    type: "phase",
+                    toolName: "lens_diagnostics",
+                    filePath: cwd,
+                    phase: "lens_diagnostics_lsp_route",
+                    durationMs: Date.now() - lspStart,
+                    metadata: {
+                        scope,
+                        isError: result.isError === true,
+                        totalDiagnostics: result.details?.totalDiagnostics ?? 0,
+                        cleanFiles: result.details?.cleanFiles ?? 0,
+                        unconfirmedFiles: result.details?.unconfirmedFiles ?? 0,
+                        timedOutFiles: result.details?.timedOutFiles ?? 0,
+                    },
+                });
+                return {
+                    ...result,
+                    isError: result.isError === true,
+                    details: { ...result.details, source, scope },
+                };
+            }
+            if (requestedSource !== undefined) {
+                const effectiveMode = legacyMode ??
+                    (scope === "workspace" ? "all" : scope === "paths" ? "all" : "delta");
+                params = { ...params, mode: effectiveMode };
+            }
             const repaintLspStatus = captureLspStatusRepaint?.(ctx);
             const mode = params.mode ?? "delta";
             const severity = params.severity ?? "all";
@@ -280,7 +395,6 @@ captureLspStatusRepaint, getRuntime) {
             const maxProjectFiles = parsePositiveInt(params.maxProjectFiles);
             const maxLspFiles = parsePositiveInt(params.maxLspFiles);
             const includeGenerated = params.includeGenerated === true;
-            const cwd = ctx.cwd ?? getCwd();
             let pathsScope;
             try {
                 pathsScope = resolvePathsScope(cwd, params.paths);
@@ -633,8 +747,7 @@ function formatDeltaMode(cacheManager, cwd, severity, pathsScope) {
     // filtered findings). Weak-anchored like weak disposition — zero I/O.
     const policyMap = loadProjectRulePolicyMap(cwd);
     const projectDelta = filterDeltaReportDispositions(loadProjectDiagnosticsDeltaReport(cwd), cwd, policyMap);
-    const ignoreFile = createCurrentIgnoreFilter(cwd);
-    const includeFile = (filePath) => ignoreFile(filePath) && (!pathsScope || pathsScope.includeFile(filePath));
+    const includeFile = createScopedFileFilter(cwd, pathsScope);
     // #755: delta re-serves the actionable/quality caches verbatim, but those
     // were filtered at DISPATCH time — before any lens_diagnostic_mark. Re-apply
     // dispositions here so a mark converges immediately, not only on the next
@@ -652,10 +765,24 @@ function formatDeltaMode(cacheManager, cwd, severity, pathsScope) {
         .filter((file) => file.warnings.length > 0);
     const actionableFiles = applyDeltaFreshnessGate(visibleWarningFiles(actionable?.files), cwd, actionable?.generatedAt);
     const qualityFiles = applyDeltaFreshnessGate(visibleWarningFiles(quality?.files), cwd, quality?.generatedAt);
+    const matchingWarnings = (warnings) => warnings.filter((warning) => matchesRecordSeverity(warning.severity, severity));
+    const filteredActionableFiles = actionableFiles
+        .map((file) => ({
+        ...file,
+        warnings: matchingWarnings(file.warnings),
+    }))
+        .filter((file) => file.warnings.length > 0);
+    const filteredQualityFiles = qualityFiles
+        .map((file) => ({
+        ...file,
+        warnings: matchingWarnings(file.warnings),
+    }))
+        .filter((file) => file.warnings.length > 0);
     const lines = [];
-    // Fixable warnings from actionable-warnings
-    if (severity !== "error") {
-        for (const file of actionableFiles) {
+    // Fixable warnings from actionable-warnings and quality cache entries retain
+    // their own severity tier. Apply the same threshold semantics as the LSP path.
+    if (filteredActionableFiles.length > 0) {
+        for (const file of filteredActionableFiles) {
             const rel = path.relative(cwd, file.filePath);
             lines.push(`${rel}`);
             for (const w of file.warnings) {
@@ -665,8 +792,8 @@ function formatDeltaMode(cacheManager, cwd, severity, pathsScope) {
         }
     }
     // Quality issues
-    if (severity !== "error") {
-        for (const file of qualityFiles) {
+    if (filteredQualityFiles.length > 0) {
+        for (const file of filteredQualityFiles) {
             const rel = path.relative(cwd, file.filePath);
             if (!lines.includes(rel))
                 lines.push(rel);
@@ -677,8 +804,10 @@ function formatDeltaMode(cacheManager, cwd, severity, pathsScope) {
         }
     }
     const projectDeltaCount = appendProjectDiagnosticsDeltaLines(lines, cwd, projectDelta, severity, includeFile);
-    const aw = actionableFiles.reduce((count, file) => count + file.warnings.length, 0);
-    const cq = qualityFiles.reduce((count, file) => count + file.warnings.length, 0);
+    const selectedActionableFiles = filteredActionableFiles;
+    const selectedQualityFiles = filteredQualityFiles;
+    const aw = selectedActionableFiles.reduce((count, file) => count + file.warnings.length, 0);
+    const cq = selectedQualityFiles.reduce((count, file) => count + file.warnings.length, 0);
     if (lines.length === 0) {
         let text = `No ${severity === "all" ? "" : severity + " "}issues in the current turn delta.`;
         // Discoverability (#190): `delta` is current-turn-scoped, so it's empty
@@ -772,6 +901,7 @@ function resolvePathsScope(cwd, rawPaths) {
     }
     const fileKeys = new Set(fileEntries.map((f) => normalizeFilePath(f)));
     const dirPrefixes = dirEntries.map((d) => normalizeFilePath(d));
+    const includeExplicitFile = (filePath) => fileKeys.has(normalizeFilePath(path.resolve(filePath)));
     const includeFile = (filePath) => {
         const key = normalizeFilePath(path.resolve(filePath));
         if (fileKeys.has(key))
@@ -780,6 +910,7 @@ function resolvePathsScope(cwd, rawPaths) {
     };
     return {
         includeFile,
+        includeExplicitFile,
         missing,
         existingEntries,
         hasDirectoryEntries: dirEntries.length > 0,
@@ -803,6 +934,16 @@ function pathsScopeMissingNote(scope) {
         : "";
     return `\n\n⚠ Skipped ${scope.missing.length} path(s) not found on disk: ${shown.join(", ")}${more}`;
 }
+function createScopedFileFilter(cwd, pathsScope) {
+    const ignoreFile = createCurrentIgnoreFilter(cwd);
+    return (filePath) => {
+        if (!pathsScope)
+            return ignoreFile(filePath);
+        if (!pathsScope.includeFile(filePath))
+            return false;
+        return pathsScope.includeExplicitFile(filePath) || ignoreFile(filePath);
+    };
+}
 function filterProjectDiagnosticsSnapshot(snapshot, includeFile) {
     if (!snapshot)
         return undefined;
@@ -845,10 +986,28 @@ function isErrorLike(d) {
     return d.semantic === "blocking" || d.severity === "error";
 }
 function matchesSeverity(d, severity) {
-    if (severity === "error")
-        return isErrorLike(d);
-    if (severity === "warning")
-        return !isErrorLike(d);
+    return matchesRecordSeverity(isErrorLike(d) ? "error" : d.severity, severity);
+}
+function matchesRecordSeverity(recordSeverity, requested) {
+    if (requested === "all")
+        return true;
+    if (requested === "error")
+        return recordSeverity === "error";
+    if (requested === "warning")
+        return recordSeverity === "error" || recordSeverity === "warning";
+    if (requested === "information")
+        return (recordSeverity === "error" ||
+            recordSeverity === "warning" ||
+            recordSeverity === "info" ||
+            recordSeverity === "note" ||
+            recordSeverity === "help");
+    if (requested === "hint")
+        return (recordSeverity === "error" ||
+            recordSeverity === "warning" ||
+            recordSeverity === "info" ||
+            recordSeverity === "note" ||
+            recordSeverity === "help" ||
+            recordSeverity === "hint");
     return true;
 }
 /** Most-important first: blocking → error → warning/other, then by line. */
@@ -918,6 +1077,14 @@ function diagnosticDedupKey(filePath, diagnostic) {
     const ruleId = normalizeRuleId(diagnostic.rule ?? diagnostic.tool ?? "");
     return [path.resolve(filePath), diagnostic.line ?? "?", ruleId].join(":");
 }
+/**
+ * Which project runner produced a retained row (#2154). ONE derivation, used by
+ * both the retirement filter and the record that counts what it retired — v2's
+ * N2 was two verbatim copies of this expression drifting apart.
+ */
+function runnerIdOf(diagnostic) {
+    return diagnostic.tool ?? diagnostic.rule?.split(":", 1)[0] ?? "";
+}
 function summarizeDiagnostics(filePath, diagnostics, hasFinalSnapshot) {
     let blocking = 0;
     let errors = 0;
@@ -1107,7 +1274,7 @@ function tallyLspPrimaryVsAuxiliary(results) {
     for (const result of results) {
         const primaryId = primaryServerId(result.filePath);
         for (const diagnostic of result.diagnostics ?? []) {
-            if (diagnostic.source === primaryId)
+            if (diagnostic.serverId === primaryId)
                 primary += 1;
             else
                 auxiliary += 1;
@@ -1115,7 +1282,7 @@ function tallyLspPrimaryVsAuxiliary(results) {
     }
     return { primary, auxiliary };
 }
-export function mergeDiagnosticsWithWidgetSummaries(widgetSummaries, lspResults, projectSnapshot, projectDelta, 
+function mergeDiagnosticsWithWidgetSummaries(widgetSummaries, lspResults, projectSnapshot, projectDelta, 
 /**
  * #1993: resolved paths covered by a CONFIRMED, fully-covered LSP result
  * in `lspResults`. The fresh sweep is AUTHORITATIVE for these files - any
@@ -1125,7 +1292,7 @@ export function mergeDiagnosticsWithWidgetSummaries(widgetSummaries, lspResults,
  * additive behavior (fail-open: unconfirmed/timed-out sweeps never retire
  * widget state they did not actually re-check).
  */
-authoritativeLspFiles) {
+authoritativeLspFiles, authoritativeRunnerIds) {
     const byFile = new Map();
     const seen = new Set();
     for (const summary of widgetSummaries) {
@@ -1138,8 +1305,18 @@ authoritativeLspFiles) {
         // suppression mechanism.
         if (authoritativeLspFiles?.has(filePath))
             continue;
-        const diagnostics = (summary.diagnostics ?? []).map((d) => ({ ...d }));
-        byFile.set(filePath, { ...summary, filePath, diagnostics });
+        const retained = summary.diagnostics ?? [];
+        const diagnostics = retained
+            .filter((diagnostic) => !authoritativeRunnerIds?.has(runnerIdOf(diagnostic)))
+            .map((d) => ({ ...d }));
+        byFile.set(filePath, 
+        // #2154 v4: when the filter retires rows, the stored tallies describe
+        // diagnostics that are no longer delivered — full mode rendered
+        // `main.go 1W … 1 warning` with no row under it. Recompute from what
+        // survived, and only then (an untouched file keeps its own counts).
+        diagnostics.length === retained.length
+            ? { ...summary, filePath, diagnostics }
+            : summarizeDiagnostics(filePath, diagnostics, summary.hasFinalSnapshot ?? true));
         for (const diagnostic of diagnostics) {
             seen.add(diagnosticDedupKey(filePath, diagnostic));
         }
@@ -1302,8 +1479,7 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
         };
     }
     const { signal, pathsScope, nextWriteIndex } = options;
-    const ignoreFile = createCurrentIgnoreFilter(cwd);
-    const includeFile = (filePath) => ignoreFile(filePath) && (!pathsScope || pathsScope.includeFile(filePath));
+    const includeFile = createScopedFileFilter(cwd, pathsScope);
     // `paths` (#461): route the active scans at exactly the requested files
     // instead of walking the whole project. Three cases:
     // - files only → pass them as the explicit list (skips the walk). An EMPTY
@@ -1335,6 +1511,7 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
         : Promise.resolve({
             diagnostics: [],
             runners: [],
+            analyzed: [],
             // #1623: every heavyweight analyzer is ELIGIBLE for this project but
             // this call never asked for it (refreshRunners wasn't cheap/all/
             // cached) — the expensive fetch below deliberately never runs in
@@ -1393,6 +1570,8 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
     const fullyCoveredLspResults = confirmedLspResults.filter((result) => (result.unconfirmedServerIds?.length ?? 0) === 0);
     const partiallyCoveredLspResults = confirmedLspResults.filter((result) => (result.unconfirmedServerIds?.length ?? 0) > 0);
     const unconfirmedLspResults = lspResults.filter((result) => result.timedOut || result.error || mismatchedLspResults.has(result));
+    const authoritativeLspFiles = new Set();
+    const unreconciledFiles = new Set();
     // #571: reconcile this scan's fresh, CONFIRMED per-file results into the
     // footer cache. A footer write is never allowed to fail the tool call, so
     // any unexpected throw is swallowed.
@@ -1413,7 +1592,7 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
             // (`applyAuxiliarySuppressions`), so an empty content string here is a
             // safe no-op re-check rather than a behavior gap.
             const retagged = retagAuxiliaryDiagnostics(diagnostics, result.diagnostics, "", { cwd, fileRole: detectFileRole(result.filePath) });
-            reconcileScanDiagnostics(result.filePath, retagged, true, 
+            const retired = reconcileScanDiagnostics(result.filePath, retagged, true, 
             // The service reserves this token when the file enters the scan. The
             // fallback preserves compatibility with older test doubles/services.
             result.writeIndex ?? nextWriteIndex?.(), 
@@ -1424,9 +1603,31 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
             // finding on screen by re-arming the mtime gate. Undefined for
             // freshly-touched results (observed now).
             result.observedAt);
+            // A result rejected by the shared ordering guard is not authoritative
+            // for delivery. Otherwise full mode hides the old widget row while
+            // mode=all still serves it, creating a false clean/full disagreement.
+            // Strict `=== true`: `undefined` (a double that predates the boolean
+            // return) takes the unreconciled arm, never the retiring one.
+            if (retired === true) {
+                authoritativeLspFiles.add(path.resolve(result.filePath));
+            }
+            else {
+                unreconciledFiles.add(path.resolve(result.filePath));
+                recordDegradationOnce({
+                    kind: "diagnostic-retained-unreconciled",
+                    subject: `${path.resolve(result.filePath)}:lsp`,
+                    reason: "confirmed diagnostic result could not replace retained widget state",
+                });
+            }
         }
         catch {
             // Never let a footer-reconciliation hiccup fail the scan itself.
+            unreconciledFiles.add(path.resolve(result.filePath));
+            recordDegradationOnce({
+                kind: "diagnostic-retained-unreconciled",
+                subject: `${path.resolve(result.filePath)}:lsp`,
+                reason: "confirmed diagnostic result failed during widget reconciliation",
+            });
         }
     }
     // Project rule policy (`.pi-lens.json` `rules.<id>.disable`/`select`) —
@@ -1454,7 +1655,15 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
     // computed above, in the SAME `Promise.all` as the LSP sweep (#613) — only
     // when the caller opted into project-runner state (otherwise it's the
     // `Promise.resolve({...})` stub from `analyzersPromise` above).
-    const projectSnapshot = applyProjectRulePolicy(foldExtraDiagnosticsIntoSnapshot(scannedSnapshot, extracted.diagnostics.filter((d) => includeFile(d.filePath)), extracted.runners, cwd), policyMap);
+    // #2154: only ids whose client said it parsed a scan of this root this call
+    // (`FreshProjectDiagnosticsResult.analyzed`). Every exclusion — a skipped
+    // runner, a crash that still reported success, the cache-read test-runner
+    // lane — is decided at the record site in fresh-fetch.ts, not re-derived
+    // here; a second list of "which ids don't count" would be the mirror this
+    // repo's single-source-of-truth rule forbids.
+    const authoritativeRunnerIds = new Set(extracted.analyzed ?? []);
+    const foldedProjectSnapshot = foldExtraDiagnosticsIntoSnapshot(scannedSnapshot, extracted.diagnostics.filter((d) => includeFile(d.filePath)), extracted.runners, cwd);
+    const projectSnapshot = applyProjectRulePolicy(foldedProjectSnapshot, policyMap);
     const projectDelta = applyProjectRulePolicy(filterProjectDiagnosticsDeltaReport(loadProjectDiagnosticsDeltaReport(cwd), includeFile), policyMap);
     // #630: only the CONFIRMED LSP results contribute diagnostics to the merge
     // — an unconfirmed (timed-out/errored) file's placeholder `[]` must not be
@@ -1464,7 +1673,6 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
     // #1993: files with a CONFIRMED, fully-covered LSP result are authoritative
     // - the fresh sweep replaces their widget-store state instead of merging
     // additively beside it.
-    const authoritativeLspFiles = new Set(fullyCoveredLspResults.map((result) => path.resolve(result.filePath)));
     // #1993 review: retirement must be observable - if a future regression
     // makes the set falsely authoritative, findings would vanish silently.
     const authoritativeRetiredCount = getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath) &&
@@ -1479,7 +1687,32 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
             metadata: { files: authoritativeRetiredCount },
         });
     }
-    const summaries = await applyInlineSuppressionsToSummaries(mergeDiagnosticsWithWidgetSummaries(getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath)), confirmedLspResults, projectSnapshot, projectDelta, authoritativeLspFiles), cwd, policyMap);
+    // #2154 v4 F2: the same rule for the runner arm, in the same shape as its
+    // LSP sibling above — a retirement nobody can see is how a regression
+    // deletes findings silently. Bounded by construction: at most one row per
+    // mode=full call, and only when rows were actually retired.
+    const runnerRetiredRows = getFileDiagnosticSummaries()
+        .filter((summary) => includeFile(summary.filePath))
+        .reduce((total, summary) => total +
+        (summary.diagnostics ?? []).filter((diagnostic) => authoritativeRunnerIds.has(runnerIdOf(diagnostic))).length, 0);
+    if (runnerRetiredRows > 0) {
+        logLatency({
+            type: "phase",
+            phase: "runner_authoritative_widget_retire",
+            filePath: "",
+            durationMs: 0,
+            metadata: {
+                rows: runnerRetiredRows,
+                runners: [...authoritativeRunnerIds].join(","),
+            },
+        });
+    }
+    let summaries = await applyInlineSuppressionsToSummaries(mergeDiagnosticsWithWidgetSummaries(getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath)), confirmedLspResults, projectSnapshot, projectDelta, authoritativeLspFiles, authoritativeRunnerIds), cwd, policyMap);
+    if (unreconciledFiles.size > 0) {
+        summaries = summaries.map((summary) => unreconciledFiles.has(path.resolve(summary.filePath))
+            ? summarizeDiagnostics(summary.filePath, markUnreconciledFindings(summary.diagnostics), summary.hasFinalSnapshot)
+            : summary);
+    }
     // #1888: the full-mode summary above is the first seam where every
     // producing lane is correlated. The earlier footer loop intentionally writes
     // only CONFIRMED LSP results, so an ast-grep backpressure failure left
@@ -1496,7 +1729,7 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
     for (const summary of summaries) {
         reconcileCorrelatedScanDiagnostics(summary.filePath, summary.diagnostics, nextWriteIndex?.(), projectScanObservedAt);
     }
-    const result = formatAllMode(cwd, severity, summaries, {
+    const result = await formatAllMode(cwd, severity, summaries, {
         mode: "full",
         lspFilesChecked: rawLspResults.length,
         partial: aborted,
@@ -1515,7 +1748,7 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
                 sources: projectDelta.sources,
                 turnIndex: projectDelta.turnIndex,
             },
-    });
+    }, 0, pathsScope);
     const missingNote = pathsScopeMissingNote(pathsScope);
     // #630: mirrors `tools/lsp-diagnostics.ts`'s `unconfirmedReasonClause`/
     // `tallyConfirmation` semantic guarantee (never silently render
@@ -1562,6 +1795,21 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
     // so a page of ast-grep/opengrep/marksman noise never buries whether the
     // real language server itself found anything in this sweep.
     const lspPrimaryVsAuxiliary = tallyLspPrimaryVsAuxiliary(confirmedLspResults);
+    logExtension({
+        subsystem: "lsp-diagnostics",
+        message: "lens_diagnostics verdict",
+        metadata: {
+            server: [
+                ...new Set(confirmedLspResults.map((result) => primaryServerId(result.filePath) ?? "unknown")),
+            ].join(","),
+            primary: lspPrimaryVsAuxiliary.primary,
+            auxiliary: lspPrimaryVsAuxiliary.auxiliary,
+            total: lspPrimaryVsAuxiliary.primary + lspPrimaryVsAuxiliary.auxiliary,
+            sources: [
+                ...new Set(confirmedLspResults.flatMap((result) => (result.diagnostics ?? []).map((diagnostic) => diagnostic.source ?? "unknown"))),
+            ].slice(0, 5),
+        },
+    });
     const lspPrimaryVsAuxiliaryNote = lspPrimaryVsAuxiliary.primary + lspPrimaryVsAuxiliary.auxiliary > 0
         ? `\n\nLSP sweep findings: ${lspPrimaryVsAuxiliary.primary} primary (language server), ` +
             `${lspPrimaryVsAuxiliary.auxiliary} auxiliary (ast-grep/opengrep/zizmor/typos/marksman/...).`
@@ -1878,8 +2126,20 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
     }
     return resultWithCold;
 }
+async function projectResolvedCwd(summary, cwd) {
+    // #2777 O1: the whole three-way lookup lives on the LSP seam now. A file
+    // with no primary LSP server is `undefined` here by construction, and
+    // formatAllMode renders that row without a cwd term (N1) — the literal
+    // `cwd=undefined` cannot be produced.
+    const resolvedCwd = await resolveLspCwdForFile(summary.filePath, cwd);
+    return {
+        ...summary,
+        ...(resolvedCwd === undefined ? {} : { resolvedCwd }),
+        diagnostics: summary.diagnostics ?? [],
+    };
+}
 // @delivery-surface: lens-diagnostics:mode-all
-function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(), detailOverrides = { mode: "all" }, staleDropped = 0, pathsScope, dependencyDemoted = 0) {
+async function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(), detailOverrides = { mode: "all" }, staleDropped = 0, pathsScope, dependencyDemoted = 0) {
     // #2275 review F2: the widget footer stops DRAWING a dependency-drift
     // demotion once it hits `DEPENDENCY_DRIFT_MAX_DELIVERIES` unconfirmed
     // deliveries, but the record stays here (dropping it would make an
@@ -1903,8 +2163,7 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
     // result there IS a legitimate clean read — the cache-only note only applies
     // to delta/all, which is why this is gated on detailOverrides.mode !== "full".
     const isFullMode = detailOverrides.mode === "full";
-    const ignoreFile = createCurrentIgnoreFilter(cwd);
-    const includeFile = (filePath) => ignoreFile(filePath) && (!pathsScope || pathsScope.includeFile(filePath));
+    const includeFile = createScopedFileFilter(cwd, pathsScope);
     // Cached summaries predate marks. Every cache-only surface re-applies
     // dispositions through the shared applyCachedDispositions seam — strict
     // false-positive anchors against current content when the file is
@@ -1955,7 +2214,7 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
         // #2414: a "warning" filter must not admit hint/info — that is exactly
         // the "present hints as warnings" defect this issue exists to close.
         if (severity === "warning")
-            return s.warnings > 0;
+            return s.blocking > 0 || s.errors > 0 || s.warnings > 0;
         // severity: "all" — a hint/info-only file (`advisories > 0`,
         // warnings === 0) must still surface here, or the #2414 fix that stops
         // hints inflating `warnings` would silently drop that file from the
@@ -1984,12 +2243,17 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
     }
     // Sort: blocking first, then errors, then warnings
     const sorted = withIssues.sort((a, b) => b.blocking - a.blocking || b.errors - a.errors || b.warnings - a.warnings);
+    // #2777 O2: only rendered rows resolve their root. The projection sits
+    // below the withIssues filter, so a 500-file session pays the cwd
+    // resolution for the handful of rows listed here, not for every summary
+    // the cache holds.
+    const rendered = await Promise.all(sorted.map((summary) => projectResolvedCwd(summary, cwd)));
     const lines = [];
     let totalBlocking = 0;
     let totalErrors = 0;
     let totalWarnings = 0;
     let totalAdvisories = 0;
-    for (const s of sorted) {
+    for (const s of rendered) {
         const rel = path.relative(cwd, s.filePath);
         const parts = [];
         if (s.blocking > 0)
@@ -2009,6 +2273,10 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
         if (staleCount > 0) {
             parts.push(`${staleCount} stale — re-run to confirm`);
         }
+        // #2777 N1: files with no primary LSP server have no resolvedCwd —
+        // omit the term rather than rendering the literal `cwd=undefined`.
+        if (s.resolvedCwd !== undefined)
+            parts.push(`cwd=${s.resolvedCwd}`);
         lines.push(`${rel}  ${parts.join("  ")}`);
         // List the actual diagnostics (not just counts) so the agent can act on
         // them without re-running anything — same "L<line>: <message>" shape as the