@herbertgao/pi-extensions 2026.9.0 → 2026.9.1

package/node_modules/pi-lens/dist/scripts/lib/skills-predicate.mjs

@@ -0,0 +1,129 @@
+// The ONE structural replica of pi's own skill-loading walk (#2626 review
+// round 2, F1/F2).
+//
+// Two independent detectors used to answer "does this directory tree hold a
+// skill pi would load" with two DIFFERENT, hand-rolled heuristics that both
+// diverged from pi's real resolver:
+//   - `clients/skills-resolver.ts` (a `SKILL.md` one level down only, no
+//     recursion, no root `.md` acceptance, no symlink-follow, no dot/
+//     node_modules skip)
+//   - `scripts/install-selftest.mjs`'s `countSkillFiles` (recursed
+//     UNBOUNDED — would double-count a `SKILL.md` sitting inside another
+//     skill's own resource subdirectory — with no dot/node_modules skip, no
+//     root `.md` acceptance, no symlink handling)
+// Neither matched `loadSkillsFromDirInternal` in
+// `@earendil-works/pi-coding-agent` `dist/core/skills.js` (mirrored by
+// `collectSkillEntries` in `dist/core/package-manager.js`, byte-identical
+// walk, confirmed against the 0.85.1 tarball). This module is the fold: BOTH
+// consumers now derive from `collectSkillEntryPaths` below.
+//
+// Discovery rules, replicated from `loadSkillsFromDirInternal` (verified
+// against the extracted 0.85.1 `skills.js`):
+//   1. If `dir` directly contains a (non-symlink-broken) `SKILL.md`, `dir` IS
+//      one skill root — return immediately, do NOT look at `dir`'s other
+//      entries or recurse into its subdirectories (a `SKILL.md` inside a
+//      skill's own reference/ subfolder is the skill's OWN resource, not a
+//      second skill).
+//   2. Otherwise, skip dot-prefixed entries and `node_modules`; recurse into
+//      every remaining subdirectory (same two rules, one level down); at the
+//      OUTERMOST call only (`isRoot`), a loose `*.md` file directly in `dir`
+//      also counts (pi's `includeRootFiles`, true only for the top call).
+//   3. A symlink is followed via `statSync` (broken symlink = skip) for BOTH
+//      the `SKILL.md` check and the directory/file classification in step 2.
+//
+// Deliberately NOT replicated (out of #2626's scope — packaging/path
+// resolution, not skill-content validation):
+//   - `.gitignore`/`.ignore`/`.fdignore` matching inside the skills tree.
+//   - frontmatter parsing: pi additionally requires a non-empty `description`
+//     field before a discovered file becomes a loaded skill. A `SKILL.md`
+//     file that exists but fails THAT validation is a content-authoring
+//     defect a maintainer would see in normal use, not a silent zero.
+// Both gaps mean this predicate can be a bit more OPTIMISTIC than pi's true
+// count in a pathological case (an ignored or description-less file still
+// counts as "found" here); it is never more PESSIMISTIC — every real skill
+// pi loads is found by this walk too — which is the direction #2626 cares
+// about (never claim "no skills" when pi would load one).
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * Symlink-aware entry classification, mirroring `loadSkillsFromDirInternal`'s
+ * own `entry.isSymbolicLink() ? statSync(fullPath) : entry`.
+ * @param {string} fullPath
+ * @param {import("node:fs").Dirent} entry
+ * @returns {"file" | "dir" | "other"}
+ */
+export function resolvedEntryKind(fullPath, entry) {
+    if (entry.isSymbolicLink()) {
+        try {
+            const stats = fs.statSync(fullPath);
+            if (stats.isDirectory())
+                return "dir";
+            if (stats.isFile())
+                return "file";
+            return "other";
+        }
+        catch {
+            return "other"; // broken symlink
+        }
+    }
+    if (entry.isDirectory())
+        return "dir";
+    if (entry.isFile())
+        return "file";
+    return "other";
+}
+/**
+ * The structural walk over an ALREADY-READ directory listing — split out
+ * from `collectSkillEntryPaths` so a caller that already has `entries` (a
+ * top-level ENOENT/EACCES distinction, say) is not forced into a second
+ * `readdirSync`.
+ * @param {string} dir
+ * @param {import("node:fs").Dirent[]} entries
+ * @param {boolean} isRoot
+ * @returns {string[]} absolute paths of every `SKILL.md` (or, at the root,
+ *   loose `.md`) file pi's own resolver would treat as a skill entry point.
+ */
+export function scanEntriesForSkills(dir, entries, isRoot) {
+    for (const entry of entries) {
+        if (entry.name === "SKILL.md" &&
+            resolvedEntryKind(path.join(dir, entry.name), entry) === "file") {
+            return [path.join(dir, entry.name)];
+        }
+    }
+    const found = [];
+    for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules") {
+            continue;
+        }
+        const fullPath = path.join(dir, entry.name);
+        const kind = resolvedEntryKind(fullPath, entry);
+        if (kind === "dir") {
+            found.push(...collectSkillEntryPaths(fullPath, false));
+            continue;
+        }
+        if (isRoot && kind === "file" && entry.name.endsWith(".md")) {
+            found.push(fullPath);
+        }
+    }
+    return found;
+}
+/**
+ * Every skill entry point under `dir`, recursively, per pi's discovery
+ * rules. Fail-closed: a `readdirSync` error at `dir` (absent, unreadable) or
+ * any recursed-into subdirectory returns `[]` for that branch rather than
+ * throwing — matching `loadSkillsFromDirInternal`'s own bare `try { … }
+ * catch {}` per directory.
+ * @param {string} dir
+ * @param {boolean} [isRoot]
+ * @returns {string[]}
+ */
+export function collectSkillEntryPaths(dir, isRoot = true) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return scanEntriesForSkills(dir, entries, isRoot);
+}

package/node_modules/pi-lens/dist/tools/effective-config.js

@@ -0,0 +1,89 @@
+/**
+ * effective_config pi tool (#2427) — the in-process half of
+ * `pilens_effective_config`.
+ *
+ * A thin wrapper over the `effectiveConfig()` engine seam
+ * (`clients/lens-engine.ts`), like `tools/symbol-search.ts` over
+ * `symbolSearch()`: the payload is byte-identical to the MCP mirror's because
+ * both render the SAME view object, and neither adapter shapes it. The whole
+ * reason the capability is an engine method rather than an MCP handler is that
+ * a second projection would be a second chance to disagree about which server
+ * is running.
+ */
+import { Type } from "../clients/deps/typebox.js";
+import { effectiveConfig, isEffectiveFileViewError, } from "../clients/lens-engine.js";
+import { compactRenderResult } from "./render-compact.js";
+/** One line per decision, for the compact renderer. */
+function summarize(view) {
+    const documents = `${view.documents.length} config file(s)`;
+    if (!view.file)
+        return `effective_config — ${documents}`;
+    if (isEffectiveFileViewError(view.file)) {
+        return `effective_config — ${documents} · ${view.file.error}`;
+    }
+    const selected = view.file.servers.filter((entry) => entry.selected).length;
+    const denied = view.file.servers.filter((entry) => entry.reason === "disabled-by-config").length;
+    const tools = view.file.tools.filter((entry) => entry.selected).length;
+    // The denial clause is built first rather than nested inside the summary
+    // template: a conditional expression inside a template inside a template is
+    // the S3358/nested-template shape SonarCloud flags, and it hid the one
+    // number a reader is looking for (#2427 review round 2, F3).
+    const deniedClause = denied > 0 ? `, ${denied} denied by config` : "";
+    return (`effective_config ${view.file.path} — ${documents} · ` +
+        `${selected} server(s) selected${deniedClause} · ` +
+        `${tools} tool(s)`);
+}
+export function createEffectiveConfigTool(getProjectRoot) {
+    return {
+        name: "effective_config",
+        label: "Effective Config",
+        description: "The resolved pi-lens configuration with the provenance of every decision — which file and tier each setting came from, and the trust decision that applied. Pass `file` to also get, for that path, its language, every LSP server with the reason it was selected or denied (including which tier's config denied it, which a nearer file cannot lift), and the lint/format runners that would dispatch. Answers 'why is X running/selected' without reading logs. Redacted by construction: it reports sources, never values — no env values, no command arguments beyond the binary, and config paths are home-relative.",
+        promptSnippet: "Resolved config + provenance — why a server or tool is selected",
+        renderResult: compactRenderResult(({ details, isError }) => isError
+            ? "effective_config — failed"
+            : (details?.summary ?? "effective_config")),
+        parameters: Type.Object({
+            file: Type.Optional(Type.String({
+                description: "Path to explain: adds the resolved language plus the per-server and " +
+                    "per-runner selection decisions for it. Must resolve inside `cwd` " +
+                    "(a sibling package in the same monorepo does not count) — a file " +
+                    "outside it is rejected with the `cwd` it was measured against; " +
+                    "re-query with `cwd` set to that file's own workspace instead.",
+            })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            const cwd = getProjectRoot() || ctx.cwd || ".";
+            const view = await effectiveConfig({
+                cwd,
+                ...(params.file === undefined ? {} : { file: params.file }),
+                redact: true,
+            });
+            const summary = summarize(view);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${summary}\n\n${JSON.stringify(view)}`,
+                    },
+                ],
+                // Summary-shaped, like `symbol_search`'s: the full view is already
+                // in `content[0].text`, and `details` exists for the renderer.
+                // Duplicating a whole provenance dump into it would double the
+                // payload of every call for one line of output.
+                details: {
+                    summary,
+                    documents: view.documents.length,
+                    provenance: view.provenance.length,
+                    ...(view.file === undefined
+                        ? {}
+                        : isEffectiveFileViewError(view.file)
+                            ? { fileError: view.file.error }
+                            : {
+                                file: view.file.path,
+                                selectedServers: view.file.servers.filter((entry) => entry.selected).length,
+                            }),
+                },
+            };
+        },
+    };
+}

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

@@ -11,8 +11,10 @@
 import { promises as fs } from "node:fs";
 import * as fsSync from "node:fs";
 import * as path from "node:path";
+import { BoundedLruCache } from "../clients/bounded-cache.js";
 import { Type } from "../clients/deps/typebox.js";
 import { anchorsForDiagnostic, applyDispositions, applyWeakDispositions, hasAnyDispositionMarks, hasStrictDispositionMarks, getDisposition, } from "../clients/diagnostic-dispositions.js";
+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";
@@ -34,7 +36,7 @@ import { ANALYZER_IDS, fetchFreshProjectDiagnostics, } from "../clients/project-
 import { loadBootstrapClients } from "../clients/bootstrap.js";
 import { generatedSkipNotice, scanTruncationNotice, } from "../clients/lens-engine.js";
 import { scanProjectDiagnostics } from "../clients/project-diagnostics/scanner.js";
-import { getFileDiagnosticSummaries, reconcileCorrelatedScanDiagnostics, reconcileScanDiagnostics, reconcileStaleWidgetDependencyBlockers, reconcileStaleWidgetFiles, widgetDiagnosticUri, } from "../clients/widget-state.js";
+import { classifyDiagnosticTier, getFileDiagnosticSummaries, reconcileCorrelatedScanDiagnostics, reconcileScanDiagnostics, reconcileStaleWidgetDependencyBlockers, reconcileStaleWidgetFiles, widgetDiagnosticUri, } from "../clients/widget-state.js";
 import { logLatency } from "../clients/latency-logger.js";
 import { convertLspDiagnostics } from "../clients/dispatch/utils/lsp-diagnostics.js";
 import { retagAuxiliaryDiagnostics } from "../clients/dispatch/auxiliary-lsp.js";
@@ -203,9 +205,15 @@ captureLspStatusRepaint, getRuntime) {
             const b = details?.totalBlocking ?? 0;
             const e = details?.totalErrors ?? 0;
             const w = details?.totalWarnings ?? 0;
+            // #2414: hint/info tier never contributes to `b + e + w` — a session
+            // with only style opinions is genuinely "clean" of code defects, but
+            // the one-line summary still names the advisory count so it isn't
+            // indistinguishable from a session with zero findings at all.
+            const adv = details?.totalAdvisories ?? 0;
             const files = details?.filesWithIssues ?? details?.filesChecked ?? 0;
             if (b + e + w === 0) {
-                return `lens_diagnostics ${mode} — clean (${files} files)${coldSuffix}${failedSuffix}`;
+                const advisorySuffix = adv > 0 ? `, ${adv} hint${adv === 1 ? "" : "s"}` : "";
+                return `lens_diagnostics ${mode} — clean${advisorySuffix} (${files} files)${coldSuffix}${failedSuffix}`;
             }
             const parts = [`${b} blocking`];
             if (b === 0 && e > 0)
@@ -417,15 +425,12 @@ function appendProjectDiagnosticsDeltaLines(lines, cwd, report, severity, includ
  * TTL. Insertion-ordered LRU cap bounds resident source bytes; repeated
  * queries and multi-file reports that cite the same file reuse one read.
  */
-const CACHED_CONTENT_MEMO_CAP = 64;
-const cachedContentMemo = new Map();
+export const CACHED_CONTENT_MEMO_CAP = 64;
+const cachedContentMemo = new BoundedLruCache(CACHED_CONTENT_MEMO_CAP);
 function readContentForAnchors(filePath, stat) {
     const key = normalizeEphemeralMapKey(filePath);
     const hit = cachedContentMemo.get(key);
     if (hit && hit.mtimeMs === stat.mtimeMs && hit.size === stat.size) {
-        // Refresh LRU position.
-        cachedContentMemo.delete(key);
-        cachedContentMemo.set(key, hit);
         return hit.content;
     }
     let content;
@@ -435,11 +440,6 @@ function readContentForAnchors(filePath, stat) {
     catch {
         return undefined;
     }
-    if (cachedContentMemo.size >= CACHED_CONTENT_MEMO_CAP) {
-        const oldest = cachedContentMemo.keys().next().value;
-        if (oldest !== undefined)
-            cachedContentMemo.delete(oldest);
-    }
     cachedContentMemo.set(key, {
         mtimeMs: stat.mtimeMs,
         size: stat.size,
@@ -447,6 +447,11 @@ function readContentForAnchors(filePath, stat) {
     });
     return content;
 }
+/** #2442 test-only: exercise the bounded content memo (LRU) directly,
+ *  without a full lens_diagnostics dispatch. */
+export function _readContentForAnchorsForTests(filePath, stat) {
+    return readContentForAnchors(filePath, stat);
+}
 /**
  * ONE disposition seam for every cache-only lens_diagnostics surface —
  * mode=all summaries, mode=delta's actionable/quality warnings, the delta
@@ -548,7 +553,35 @@ function loadProjectRulePolicyMap(cwd) {
  * `clients/finding-delivery-gate.ts` surface `lens-diagnostics:mode-delta`.
  */
 function applyDeltaFreshnessGate(files, cwd, generatedAt) {
-    if (!generatedAt)
+    // #2504 review round 4 (F1): an actionable-warnings report is no longer the
+    // product of exactly ONE pass. A deferred off-hook LSP pull upserts its
+    // per-file entries into whatever report is persisted when it lands, so one
+    // report can carry entries observed minutes apart. Judging the older half
+    // against the newer report-level stamp would pass an out-of-band edit made
+    // in between off as live -- exactly the leak this gate exists to stop. Each
+    // distinct stamp is gated on its own; the ordinary single-stamp report
+    // takes one pass, as before, and the original file order is preserved.
+    const stamps = new Set(files.map((file) => file.generatedAt ?? generatedAt ?? ""));
+    if (stamps.size > 1) {
+        const gatedByPath = new Map();
+        for (const stamp of stamps) {
+            const group = files.filter((file) => (file.generatedAt ?? generatedAt ?? "") === stamp);
+            for (const gated of applyDeltaFreshnessGate(group.map((file) => ({
+                filePath: file.filePath,
+                warnings: file.warnings,
+            })), cwd, stamp === "" ? undefined : stamp)) {
+                gatedByPath.set(gated.filePath, gated);
+            }
+        }
+        return files
+            .map((file) => gatedByPath.get(file.filePath))
+            .filter((entry) => entry !== undefined);
+    }
+    // Every entry shares one stamp here; prefer the per-entry one when it has
+    // it, so a merged report's single surviving half is still aged by its own.
+    const stampedAt = [...stamps][0];
+    const effectiveAt = stampedAt !== undefined && stampedAt !== "" ? stampedAt : generatedAt;
+    if (!effectiveAt)
         return files;
     const flat = [];
     for (const file of files) {
@@ -561,7 +594,7 @@ function applyDeltaFreshnessGate(files, cwd, generatedAt) {
         store: "lens-diagnostics-delta",
         findings: flat,
         cwd,
-        scannedAt: generatedAt,
+        scannedAt: effectiveAt,
         citedPath: (f) => f.filePath,
         onMissing: "drop",
     });
@@ -611,6 +644,9 @@ function formatDeltaMode(cacheManager, cwd, severity, pathsScope) {
         .filter((file) => includeFile(file.filePath))
         .map((file) => ({
         filePath: file.filePath,
+        // #2504 r4 (F1): carried through, so a merged report's older
+        // entries keep their own age all the way to the freshness gate.
+        generatedAt: file.generatedAt,
         warnings: applyRulePolicy(applyCachedDispositions(file.warnings ?? [], cwd, file.filePath), policyMap),
     }))
         .filter((file) => file.warnings.length > 0);
@@ -886,6 +922,7 @@ function summarizeDiagnostics(filePath, diagnostics, hasFinalSnapshot) {
     let blocking = 0;
     let errors = 0;
     let warnings = 0;
+    let advisories = 0;
     for (const diagnostic of diagnostics) {
         // #1641: a demoted past-EOF entry keeps its severity for display but
         // drops out of the tallies — same reasoning as widget-state's `isBlocking`.
@@ -893,24 +930,28 @@ function summarizeDiagnostics(filePath, diagnostics, hasFinalSnapshot) {
             continue;
         if (diagnostic.semantic === "blocking")
             blocking++;
-        if (diagnostic.severity === "error")
+        // #2414: severity → tier classification is shared with
+        // `countDiagnostics`/`countAdvisories` in `clients/widget-state.ts` via
+        // `classifyDiagnosticTier` — mode=all reads that store's tally and
+        // mode=full reads this one, so the two must agree. `hint`/`info` no
+        // longer inflate `warnings` (they used to, matching a pre-#2414
+        // `countDiagnostics`, so a hint-only file scored 0/0/0 there too and the
+        // `withIssues` filter below dropped it — that gap is now closed via
+        // `advisories`, not by re-folding hints into `warnings`).
+        const tier = classifyDiagnosticTier(diagnostic);
+        if (tier === "error")
             errors++;
-        // #1777: `hint` and `info` tally alongside `warning`, matching
-        // `countDiagnostics` in `clients/widget-state.ts` — mode=all reads that
-        // tally and mode=full reads this one, so the two must agree. An exact
-        // `=== "warning"` test scored a hint-only file 0/0/0, the `withIssues`
-        // filter below then dropped it, and mode=full rendered "No issues" for a
-        // file whose own `details` still carried the diagnostic.
-        else if (diagnostic.severity === "warning" ||
-            diagnostic.severity === "hint" ||
-            diagnostic.severity === "info")
+        else if (tier === "warning")
             warnings++;
+        else if (tier === "advisory")
+            advisories++;
     }
     return {
         filePath,
         blocking,
         errors,
         warnings,
+        advisories,
         hasFinalSnapshot,
         diagnostics,
     };
@@ -1839,6 +1880,13 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
 }
 // @delivery-surface: lens-diagnostics:mode-all
 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
+    // unconfirmed LSP error read as clean). Say so, through the same note
+    // channel as the demotion itself, so the agent knows why the footer went
+    // quiet and that a re-run can still confirm the finding.
+    const footerCapped = summaries.reduce((n, s) => n + (s.diagnostics ?? []).filter((d) => d.footerRetired === true).length, 0);
     // Files changed/deleted since their diagnostics were recorded have already
     // been dropped by reconcileStaleWidgetFiles; note them so the agent knows
     // those aren't "clean", just un-rescanned (use mode=full to refresh).
@@ -1847,6 +1895,9 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
         : "") +
         (dependencyDemoted > 0
             ? ` (${dependencyDemoted} blocking finding${dependencyDemoted === 1 ? "" : "s"} demoted to [stale] — an imported file changed since; re-run to confirm)`
+            : "") +
+        (footerCapped > 0
+            ? ` (${footerCapped} demoted finding${footerCapped === 1 ? "" : "s"} capped after ${DEPENDENCY_DRIFT_MAX_DELIVERIES} unconfirmed deliveries — no longer shown in the pi-lens footer, still listed here; re-run to confirm)`
             : "");
     // mode=full already actively scanned exactly the requested paths, so a zero
     // result there IS a legitimate clean read — the cache-only note only applies
@@ -1901,11 +1952,18 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
     const withIssues = visibleSummaries.filter((s) => {
         if (severity === "error")
             return s.blocking > 0 || s.errors > 0;
+        // #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;
+        // 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
+        // detailed listing instead of just from the compact warning tally.
         return (s.blocking > 0 ||
             s.errors > 0 ||
             s.warnings > 0 ||
+            s.advisories > 0 ||
             (s.diagnostics ?? []).some((d) => d.stale));
     });
     const pathsNote = isFullMode ? "" : pathsScopeCacheOnlyNote(pathsScope);
@@ -1930,6 +1988,7 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
     let totalBlocking = 0;
     let totalErrors = 0;
     let totalWarnings = 0;
+    let totalAdvisories = 0;
     for (const s of sorted) {
         const rel = path.relative(cwd, s.filePath);
         const parts = [];
@@ -1939,6 +1998,11 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
             parts.push(`${s.errors}E`);
         if (s.warnings > 0)
             parts.push(`${s.warnings}W`);
+        // #2414: hint/info never inflate `warnings`, but a hint-only row still
+        // needs a reason to be listed — otherwise it shows a bare filename with
+        // no count at all.
+        if (s.advisories > 0)
+            parts.push(`${s.advisories} hint${s.advisories === 1 ? "" : "s"}`);
         if (!s.hasFinalSnapshot)
             parts.push(`(pending)`);
         const staleCount = (s.diagnostics ?? []).filter((d) => d.stale).length;
@@ -1984,6 +2048,7 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
         totalBlocking += s.blocking;
         totalErrors += s.errors;
         totalWarnings += s.warnings;
+        totalAdvisories += s.advisories;
     }
     // #1799: `totalBlocking` and `totalErrors` count the same findings UNLESS a
     // dependency-drift demotion (#1631) has revoked blocking authority from an
@@ -2004,6 +2069,11 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
         totalWarnings > 0
             ? `  ${totalWarnings} warning${totalWarnings === 1 ? "" : "s"}`
             : null,
+        // #2414: reported separately from `warnings` — hint/info are style
+        // opinions, not defects, and must not read as unresolved code issues.
+        totalAdvisories > 0
+            ? `  ${totalAdvisories} hint/info (style — not counted as warnings)`
+            : null,
     ]
         .filter(Boolean)
         .join("\n");
@@ -2017,6 +2087,7 @@ function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(),
             totalBlocking,
             totalErrors,
             totalWarnings,
+            totalAdvisories,
             staleDropped,
         },
     };