• Track which override selectors are actually applied during dependency resolution.
• Emit pnpm:unusedOverride for selectors that matched nothing (gated to full resolution).
• Buffer and print one grouped WARN line at resolution_done in TS and pacquet.

graph TD
I["Installer (pnpm install)"] -->|"no overrides"| S{{"pnpr server"}}
I --> H["Versions overrider hook"] --> A[("Applied selectors set")] --> D["Post-resolution diff"] --> E(("pnpm:unusedOverride")) --> R["Default reporter buffer"] --> W["Grouped WARN line"]
subgraph Legend
direction LR
_mod["Module"] ~~~ _db[("State/Set")] ~~~ _evt(("Log event")) ~~~ _ext{{"External"}}
end

Loading

The following are alternative approaches to this PR:

1. Resolver-level reporting of matched overrides

• ➕ More accurate than hook-based tracking (fewer incidental “applied” signals).
• ➕ Would avoid gating logic tied to full lockfile reanalysis.
• ➖ Requires deeper resolver protocol/API changes (including pnpr server), larger scope.
• ➖ Harder to keep TS and pacquet implementations aligned.

2. Warn immediately per unused override (no buffering)

• ➕ Simpler reporter logic; warnings appear as soon as known.
• ➖ Noisier output and worse UX for many overrides.
• ➖ Harder to avoid interleaving with progress output.

3. Lockfile-only detection (compare overrides vs lockfile contents)

• ➕ Avoids hook plumbing and applied-selector tracking.
• ➖ Unreliable: overrides may affect resolution without obvious lockfile fingerprints.
• ➖ Does not naturally handle parent-scoped selectors or direct-add flows.

Recommendation: Keep the PR’s approach: track selector application during manifest processing, then diff post-resolution and buffer output until resolution_done. It minimizes user-facing noise, keeps correctness via the full-resolution gate, and is implementable with close TS/pacquet parity. The main alternative (resolver-level reporting) is attractive long-term, but substantially larger in scope and would require pnpr protocol work.

Enhancement (14) +254 / -19

state.rsBuffer unused override selectors and flush as grouped warning +36/-0

Buffer unused override selectors and flush as grouped warning

• Adds reporter state to collect 'pnpm:unusedOverride' selectors. Flushes them on 'Stage::ResolutionDone' into a single sorted warning line with correct singular/plural handling.

pacquet/crates/default-reporter/src/state.rs

install_with_fresh_lockfile.rsEmit UnusedOverride events after resolution and before ResolutionDone +35/-1

Emit UnusedOverride events after resolution and before ResolutionDone

• Computes the set difference between parsed override selectors and the overrider’s applied selectors. Emits one 'LogEvent::UnusedOverride' per unmatched selector, then emits 'Stage::ResolutionDone' to trigger reporter flush.

pacquet/crates/package-manager/src/install_with_fresh_lockfile.rs

overrides.rsTrack which override selectors matched in VersionsOverrider +33/-2

Track which override selectors matched in VersionsOverrider

• Extends 'VersionsOverrider' with a mutex-protected 'HashSet' recording applied selectors. Records hits when overrides are chosen and exposes 'applied_selectors()' for post-resolution verification.

pacquet/crates/package-manager/src/overrides.rs

lib.rsAdd 'pnpm:unusedOverride' log event and payload type +21/-0

Add 'pnpm:unusedOverride' log event and payload type

• Introduces 'LogEvent::UnusedOverride' and 'UnusedOverrideLog' with 'prefix' and raw 'selector'. Documents intended buffering behavior in the default reporter.

pacquet/crates/reporter/src/lib.rs

index.tsPlumb 'pnpm:unusedOverride' into default reporter streams +5/-0

Plumb 'pnpm:unusedOverride' into default reporter streams

• Adds an RxJS subject for 'pnpm:unusedOverride' and routes parsed logs into it. Exposes the observable to downstream reporter composition.

pnpm11/cli/default-reporter/src/index.ts

index.tsWire unused override reporter into client reporter pipeline +6/-0

Wire unused override reporter into client reporter pipeline

• Adds 'reportUnusedOverrides' to the composed output pipeline and passes both the unusedOverride and stage streams needed for buffering until 'resolution_done'.

pnpm11/cli/default-reporter/src/reporterForClient/index.ts

reportUnusedOverrides.tsImplement grouped warning rendering for unused overrides +31/-0

Implement grouped warning rendering for unused overrides

• Buffers 'UnusedOverrideLog' events until the 'resolution_done' stage, then emits one WARN line listing sorted selectors. Handles pluralization and emits nothing when the buffer is empty.

pnpm11/cli/default-reporter/src/reporterForClient/reportUnusedOverrides.ts

all.tsExport unusedOverrideLogger from core-loggers barrel +1/-0

Export unusedOverrideLogger from core-loggers barrel

• Adds the new unused override logger module to the package’s public export surface.

pnpm11/core/core-loggers/src/all.ts

index.tsInclude UnusedOverrideLog in the union of known log types +2/-0

Include UnusedOverrideLog in the union of known log types

• Extends the 'Log' discriminated union to include 'UnusedOverrideLog' so consumers can handle the new 'pnpm:unusedOverride' channel.

pnpm11/core/core-loggers/src/index.ts

unusedOverrideLogger.tsIntroduce 'unusedOverrideLogger' and log payload types +14/-0

Introduce 'unusedOverrideLogger' and log payload types

• Adds a dedicated logger for 'pnpm:unusedOverride' events with a minimal payload of 'prefix' and raw override 'selector'.

pnpm11/core/core-loggers/src/unusedOverrideLogger.ts

createReadPackageHook.tsThread 'onOverrideApplied' callback into versions overrider hook +5/-2

Thread 'onOverrideApplied' callback into versions overrider hook

• Updates 'createReadPackageHook' to accept an optional 'onOverrideApplied' callback and passes it to 'createVersionsOverrider'. Broadens override input typing to preserve raw selectors when available.

pnpm11/hooks/read-package-hook/src/createReadPackageHook.ts

createVersionsOverrider.tsAdd 'onApplied' callback and preserve raw selector typing +29/-11

Add 'onApplied' callback and preserve raw selector typing

• Extends 'createVersionsOverrider' with an optional 'onApplied' callback invoked when an override with a raw 'selector' matches a dependency entry. Keeps the older selector-stripped type as a deprecated alias for backward compatibility.

pnpm11/hooks/read-package-hook/src/createVersionsOverrider.ts

extendInstallOptions.tsExpose 'appliedOverrides' Set and record matches via read-package hook +4/-0

Expose 'appliedOverrides' Set and record matches via read-package hook

• Adds 'appliedOverrides: Set<string>' to 'ProcessedInstallOptions'. Initializes the set and wires 'createReadPackageHook' to record 'override.selector' when applied.

pnpm11/installing/deps-installer/src/install/extendInstallOptions.ts

index.tsEmit unused override logs post-resolution; skip pnpr server when overrides exist +32/-3

Emit unused override logs post-resolution; skip pnpr server when overrides exist

• Falls back to local resolution when a pnpr server is configured but overrides are present, because the pnpr protocol cannot report matched selectors. After resolution (and only under a full-reanalysis gate), emits 'pnpm:unusedOverride' for selectors not in 'appliedOverrides', before the 'resolution_done' stage.

pnpm11/installing/deps-installer/src/install/index.ts

Bug fix (1) +2 / -0

parseWantedDependencies.tsMark override as applied for direct adds when override rewrites spec +2/-0

Mark override as applied for direct adds when override rewrites spec

• Adds an optional 'onOverrideApplied' callback and calls it when a directly-added dependency alias is overridden. Prevents false unused-override warnings for 'pnpm add' flows.

pnpm11/installing/deps-installer/src/parseWantedDependencies.ts

Tests (8) +513 / -5

render.rsTest pacquet reporter buffering/formatting for unused overrides +68/-1

Test pacquet reporter buffering/formatting for unused overrides

• Adds tests asserting unused overrides are buffered until 'ResolutionDone', sorted, grouped into one WARN line, singularized for one item, and omitted when empty.

pacquet/crates/default-reporter/tests/render.rs

tests.rsTest applied selector tracking in VersionsOverrider +66/-0

Test applied selector tracking in VersionsOverrider

• Adds coverage ensuring applied selectors include matched overrides (including deletions), remain empty when no matches occur, and dedupe across multiple apply calls.

pacquet/crates/package-manager/src/overrides/tests.rs

tests.rsVerify 'pnpm:unusedOverride' wire shape matches pnpm +24/-1

Verify 'pnpm:unusedOverride' wire shape matches pnpm

• Adds a serialization test confirming 'pnpm:unusedOverride' JSON envelope includes 'level', 'prefix', and 'selector' at the top level with the correct event name.

pacquet/crates/reporter/src/tests.rs

reportingUnusedOverrides.tsAdd unit tests for TS default reporter unused-override output +102/-0

Add unit tests for TS default reporter unused-override output

• Verifies the reporter prints a single grouped line at 'resolution_done', uses singular form for a single selector, and emits nothing when no unused-override events exist.

pnpm11/cli/default-reporter/test/reportingUnusedOverrides.ts

createVersionOverrider.test.tsTest 'onApplied' callback behavior and call frequency contract +63/-0

Test 'onApplied' callback behavior and call frequency contract

• Adds tests ensuring 'onApplied' is called for each matched override and documents that the callback fires per (manifest × dependency-group) pass, with downstream deduping handled by a Set.

pnpm11/hooks/read-package-hook/test/createVersionOverrider.test.ts

overrides.tsAdd integration tests for emitting/avoiding 'pnpm:unusedOverride' +50/-2

Add integration tests for emitting/avoiding 'pnpm:unusedOverride'

• Introduces tests asserting unused override logs are emitted for unmatched selectors and omitted when overrides match (including ensuring direct-add override usage is not falsely flagged).

pnpm11/installing/deps-installer/test/install/overrides.ts

pnpmRegistry.tsTest pnpr server is bypassed when overrides are configured +31/-1

Test pnpr server is bypassed when overrides are configured

• Adds a registry harness test verifying pnpm does not hit the pnpr server when overrides exist, and that a grouped unused-override warning is printed for unmatched selectors only.

pnpm11/pnpm/test/install/pnpmRegistry.ts

unusedOverrides.tsAdd end-to-end tests for unused override warning output +109/-0

Add end-to-end tests for unused override warning output

• Adds CLI-level tests verifying warnings appear only for unused overrides, remain absent when all overrides match, and work with per-project overrides when 'sharedWorkspaceLockfile' is disabled.

pnpm11/pnpm/test/install/unusedOverrides.ts

Documentation (1) +18 / -0

warn-unused-overrides.mdAdd release note and version bumps for unused override warnings +18/-0

Add release note and version bumps for unused override warnings

• Introduces a changeset announcing install-time warnings for overrides that match no dependency. Documents the new logger channel, hook callback, installer state exposure, and reporter behavior (including pacquet parity).

.changeset/warn-unused-overrides.md

Walkthrough

Adds install-time detection for override selectors that match no dependency, emits a dedicated unused-override log at resolution completion, and renders it as a grouped warning in the default reporters. The change also threads applied-selector tracking through override application and adds coverage for install, reporter, and lockfile-scanning paths.

Changes

Unused overrides warning

Estimated code review effort: 4 (Complex) | ~60 minutes

Assessment against linked issues

Out-of-scope changes

No out-of-scope code changes identified.

Possibly related PRs

• pnpm/pnpm#12283: Overlaps in pacquet/crates/package-manager/src/install_with_fresh_lockfile.rs around lockfile reuse and resolution-path behavior.
• pnpm/pnpm#12345: Also changes pacquet/crates/package-manager/src/overrides.rs override application behavior.

Suggested labels: product: pacquet, product: pnpm@11

Suggested reviewers: zkochan

• X
• Mastodon
• Reddit
• LinkedIn

Description

reportUnusedOverrides() buffers all pnpm:unused-override events globally and flushes them on the
first resolution_done stage event without partitioning by log.prefix. In recursive/multi-prefix
runs this can mix selectors across workspaces/lockfileDirs or flush too early, leading to missing,
incorrect, or ambiguous warnings that fail to clearly identify which override selectors matched
nothing.

Code

pnpm11/cli/default-reporter/src/reporterForClient/reportUnusedOverrides.ts[R25-41]

+  const resolutionDone$ = log$.stage.pipe(
+    filter((log) => log.stage === 'resolution_done')
+  )
+  return log$.unusedOverride.pipe(
+    buffer(resolutionDone$),
+    map((unusedOverrides) => {
+      if (unusedOverrides.length === 0) return Rx.EMPTY
+      const selectors = unusedOverrides
+        .map((log) => sanitizeSelector(log.selector))
+        .sort()
+      const head = selectors.length === 1
+        ? '1 override matched no dependency'
+        : `${selectors.length} overrides matched no dependency`
+      return Rx.of({
+        msg: formatWarn(`${head}: ${selectors.join(', ')}`),
+      })
+    })

Evidence

PR Compliance ID 1 requires pnpm install to emit a clear warning identifying which override
selector(s) matched nothing, but the reporter implementation buffers unusedOverride logs and emits
them on resolution_done without ever scoping by or reading log.prefix. This is problematic
because both pnpm:unused-override and pnpm:stage events include prefix: ctx.lockfileDir, so in
multi-prefix installs a resolution_done from one prefix can flush buffered selectors from another,
and selectors from different lockfileDirs can be merged into a single warning; other reporters use
log.prefix to disambiguate output, underscoring that prefix is intended to separate and
contextualize per-project reporting.

Warn when a pnpm override selector matches no packages
pnpm11/cli/default-reporter/src/reporterForClient/reportUnusedOverrides.ts[25-41]
pnpm11/cli/default-reporter/src/reporterForClient/index.ts[111-119]
pnpm11/cli/default-reporter/src/reporterForClient/reportUnusedOverrides.ts[19-43]
pnpm11/core/core-loggers/src/unusedOverrideLogger.ts[7-14]
pnpm11/installing/deps-installer/src/install/index.ts[1662-1685]
pnpm11/cli/default-reporter/src/reporterForClient/reportDeprecations.ts[19-34]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`reportUnusedOverrides()` currently ignores `UnusedOverrideLog.prefix`/`StageLog.prefix`, buffering all `pnpm:unused-override` events together and flushing them on any `resolution_done` stage event. In multi-prefix (recursive) installs this can merge selectors from different workspaces/lockfileDirs or flush before all selectors for a given prefix have arrived, producing missing, incorrect, or context-free warnings.

## Issue Context
- PR Compliance ID 1 requires `pnpm install` to emit a clear warning identifying which override selector(s) matched nothing.
- Each `pnpm:unused-override` (`UnusedOverrideLog`) and `pnpm:stage` (`StageLog`) event includes a `prefix` (workspace root / lockfileDir, typically `ctx.lockfileDir`).
- The warning needs to be accurate per-prefix; other reporters use `log.prefix` to disambiguate output (e.g., via zoom-out/prefix formatting).

## Fix Focus Areas
- pnpm11/cli/default-reporter/src/reporterForClient/reportUnusedOverrides.ts[19-43]
- pnpm11/cli/default-reporter/src/reporterForClient/index.ts[111-119]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

pacquet emits unused-override events only when lockfile_for_reuse.is_none(), but
UpdateReuseScope::None disables reuse (full re-resolve) while lockfile_for_reuse can still be
Some. This suppresses unused-override warnings in full re-resolution flows like pacquet update,
undermining the feature.

Code

pacquet/crates/package-manager/src/install_with_fresh_lockfile.rs[R1216-1225]

+        if lockfile_for_reuse.is_none()
+            && let Some(overrider) = versions_overrider.as_ref()
+            && let Some(parsed) = parsed_overrides.as_ref()
+        {
+            let applied = overrider.applied_selectors();
+            let mut unused: Vec<&str> = parsed
+                .iter()
+                .map(|override_entry| override_entry.selector.as_str())
+                .filter(|selector| !applied.contains(*selector))
+                .collect();

Evidence

The emission site gates on lockfile_for_reuse.is_none(). However, update_reuse_scope can be set
to None (e.g. update flows / force resolve), and the resolver will not reuse any subtree when that
scope is None, meaning applied selectors would be complete but the warning is still skipped.

pacquet/crates/package-manager/src/install_with_fresh_lockfile.rs[1202-1234]
pacquet/crates/package-manager/src/install_with_fresh_lockfile.rs[1048-1109]
pacquet/crates/resolving-deps-resolver/src/resolve_dependency_tree.rs[48-63]
pacquet/crates/resolving-deps-resolver/src/resolve_dependency_tree.rs[2089-2097]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

### Issue description
The unused-override diff is gated by `lockfile_for_reuse.is_none()`, but pacquet can still perform a full re-resolve (no subtree reuse) when `update_reuse_scope` is `UpdateReuseScope::None` even if a prior lockfile exists. In that case `applied_selectors()` should be complete and the warning should run, but currently it is skipped.

### Issue Context
`UpdateReuseScope::None` explicitly means “reuse nothing — the whole graph re-resolves”, and the resolver’s reuse path short-circuits when this scope is set.

### Fix Focus Areas
- pacquet/crates/package-manager/src/install_with_fresh_lockfile.rs[1048-1110]
- pacquet/crates/package-manager/src/install_with_fresh_lockfile.rs[1202-1234]
- pacquet/crates/resolving-deps-resolver/src/resolve_dependency_tree.rs[48-63]
- pacquet/crates/resolving-deps-resolver/src/resolve_dependency_tree.rs[2089-2097]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

findAppliedOverrideSelectorsFromLockfile() checks only importer dependencies/dev/optional when
matching workspace-project parents, so overrides that apply only to a workspace project’s
peerDependencies can be incorrectly reported as unused in pnpr-server mode.

Code

pnpm11/installing/deps-installer/src/install/findAppliedOverrides.ts[R44-60]

+      for (const { importerId, manifest: projectManifest } of projectManifests) {
+        if (projectManifest.name !== parentName) continue
+        if (parentRange != null) {
+          const projectVersion = projectManifest.version
+          if (projectVersion == null) continue
+          if (!parentRangeValid || !semver.satisfies(projectVersion, parentRange)) continue
+        }
+        const importer = lockfile.importers[importerId as ProjectId]
+        if (importer == null) continue
+        if (
+          depEntryMatches(importer.dependencies, targetName) ||
+          depEntryMatches(importer.devDependencies, targetName) ||
+          depEntryMatches(importer.optionalDependencies, targetName)
+        ) {
+          applied.add(override.selector)
+          break
+        }

Evidence

Overrides are applied to peerDependencies in the read-package hook and count as ‘applied’ hits
there, but the pnpr-server lockfile scan only inspects importer dependency maps (which omit peers)
when using project manifests to match a workspace parent, so peer-only hits won’t be recognized.

pnpm11/installing/deps-installer/src/install/findAppliedOverrides.ts[39-61]
pnpm11/hooks/read-package-hook/src/createVersionsOverrider.ts[85-105]
pnpm11/core/types/src/package.ts[90-106]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The pnpr-server unused-override detector determines “applied” selectors by scanning lockfile importer/package snapshots. For workspace projects it uses `projectManifests` to match the parent name/version, but then only checks the lockfile importer’s `dependencies/devDependencies/optionalDependencies` maps.
However, the override application hook (`createVersionsOverrider`) also applies overrides to `peerDependencies` and reports hits via `onApplied`. Because lockfile importers do not represent `peerDependencies`, an override that only matches a workspace project’s peerDependencies can be treated as unused by the pnpr-server scan.
### Issue Context
This affects pnpr-server mode specifically, where applied selectors are reconstructed from the resolved lockfile instead of being collected during manifest hook execution.
### Fix Focus Areas
- pnpm11/installing/deps-installer/src/install/findAppliedOverrides.ts[39-61]
- pnpm11/hooks/read-package-hook/src/createVersionsOverrider.ts[85-105]
### Suggested fix
When evaluating workspace project matches (and potentially for the generic/non-parent path too), also consult `projectManifest.peerDependencies` (and, for completeness, `projectManifest.dependencies/devDependencies/optionalDependencies`) for `targetName`.
Concretely:
- In the `projectManifests` loop, add checks like `depEntryMatches(projectManifest.peerDependencies, targetName)`.
- Consider checking the project manifest’s dependency fields before/without requiring a corresponding lockfile importer entry, since the manifest is the authoritative source for peerDependencies.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

In pnpr-server mode, findAppliedOverrideSelectorsFromLockfile() only consults workspace project
manifests (for peerDependencies) when the override is parent-scoped; generic overrides never check
projectManifests and therefore can’t match a workspace project’s peerDependencies. This can
incorrectly warn that a generic override is unused even though it matched a workspace manifest
peerDependency.

Code

pnpm11/installing/deps-installer/src/install/findAppliedOverrides.ts[R39-89]

+    if (override.parentPkg != null) {
+      const parentName = override.parentPkg.name
+      const parentRange = override.parentPkg.bareSpecifier
+      const parentRangeValid = parentRange == null || semver.validRange(parentRange) != null
+
+      for (const { importerId, manifest: projectManifest } of projectManifests) {
+        if (projectManifest.name !== parentName) continue
+        if (parentRange != null) {
+          const projectVersion = projectManifest.version
+          if (projectVersion == null) continue
+          if (!parentRangeValid || !semver.satisfies(projectVersion, parentRange)) continue
+        }
+        // Importer snapshots don't carry peerDependencies, so check the
+        // manifest directly for that field. The other three groups are
+        // covered by the importer entry (resolved deps share the same
+        // names as the manifest).
+        const importer = lockfile.importers[importerId as ProjectId]
+        if (
+          (importer != null && targetInImporter(importer, targetName)) ||
+          depEntryMatches(projectManifest.peerDependencies, targetName)
+        ) {
+          applied.add(override.selector)
+          break
+        }
+      }
+      if (applied.has(override.selector)) continue
+
+      for (const [depPath, snapshot] of packageEntries) {
+        const { name, version } = nameVerFromPkgSnapshot(depPath, snapshot)
+        if (name !== parentName) continue
+        if (parentRange != null && (version == null || !parentRangeValid || !semver.satisfies(version, parentRange))) continue
+        if (targetInSnapshot(snapshot, targetName)) {
+          applied.add(override.selector)
+          break
+        }
+      }
+    } else {
+      for (const importer of importerSnapshots) {
+        if (targetInImporter(importer, targetName)) {
+          applied.add(override.selector)
+          break
+        }
+      }
+      if (applied.has(override.selector)) continue
+      for (const snapshot of packageSnapshots) {
+        if (targetInSnapshot(snapshot, targetName)) {
+          applied.add(override.selector)
+          break
+        }
+      }
+    }

Evidence

The function explicitly notes importers don’t carry peerDependencies and checks
projectManifest.peerDependencies only for parent-scoped overrides. For generic overrides, it scans
only importer snapshots (no peerDeps) and package snapshots, so a workspace project
peerDependency-only match is invisible and will be treated as unused.

pnpm11/installing/deps-installer/src/install/findAppliedOverrides.ts[39-63]
pnpm11/installing/deps-installer/src/install/findAppliedOverrides.ts[75-89]
pnpm11/installing/deps-installer/src/install/findAppliedOverrides.ts[95-104]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

### Issue description
`findAppliedOverrideSelectorsFromLockfile()` has special handling for importer peerDependencies via `projectManifests`, but only in the parent-scoped override branch. Generic overrides (no `parentPkg`) can apply to workspace project `peerDependencies` too, yet the scan never checks them, leading to false `pnpm:unused-override` warnings in pnpr-server installs.

### Issue Context
Importer snapshots do not contain peerDependencies, so the scan already relies on `projectManifests` to see workspace peers in the parent-scoped path. The same limitation applies to the generic path.

### Fix Focus Areas
- pnpm11/installing/deps-installer/src/install/findAppliedOverrides.ts[39-90]
- pnpm11/installing/deps-installer/src/install/findAppliedOverrides.ts[95-104]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

In pacquet’s default reporter, the grouped unused-override summary is emitted via push_warning(),
so once more than MAX_SHOWN_WARNINGS warnings have already been shown, this message can be
replaced by the generic “X other warnings” line and users won’t see which overrides were unused.

Code

pacquet/crates/default-reporter/src/state.rs[R466-472]

+        let head = if sanitized.len() == 1 {
+            "1 override matched no dependency".to_string()
+        } else {
+            format!("{} overrides matched no dependency", sanitized.len())
+        };
+        self.push_warning(&format!("{}: {}", head, sanitized.join(", ")));
+    }

Evidence

flush_pending_unused_overrides() emits the grouped message with self.push_warning(...).
push_warning() increments warnings_counter and, after MAX_SHOWN_WARNINGS, replaces subsequent
warnings with a collapsed “X other warnings” message—so the unused-override summary can be
suppressed.

pacquet/crates/default-reporter/src/state.rs[446-472]
pacquet/crates/default-reporter/src/state.rs[240-241]
pacquet/crates/default-reporter/src/state.rs[1012-1025]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The unused-override grouped warning is currently emitted through `push_warning()`. That function enforces pnpm’s “show first N warnings then collapse the rest” behavior, meaning the unused-override summary can be hidden behind a generic “X other warnings” line when many warnings occur.
### Issue Context
This is a new warn surface intended to be actionable; hiding it makes the feature unreliable in real-world installs that already produce many warnings (e.g. deprecations).
### Fix Focus Areas
- pacquet/crates/default-reporter/src/state.rs[458-472]
- pacquet/crates/default-reporter/src/state.rs[1012-1025]
- pacquet/crates/default-reporter/src/state.rs[240-241]
### Suggested change
Emit the grouped unused-override summary using a non-collapsing path (e.g. `push_block(format!("{} {message}", warn_label))`) or otherwise ensure it is always rendered even after `MAX_SHOWN_WARNINGS` is exceeded (e.g. a dedicated method that prints with `[WARN]` styling but does not increment/collapse the global warnings counter).

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

reportUnusedOverrides buffers all pnpm:unused-override events until resolution_done and then
concatenates every selector into one WARN line with no cap. A repo with many/very-long override keys
can cause large temporary allocations and huge log output during install, degrading performance and
potentially destabilizing the process.

Code

pnpm11/cli/default-reporter/src/reporterForClient/reportUnusedOverrides.ts[R25-41]

+  const resolutionDone$ = log$.stage.pipe(
+    filter((log) => log.stage === 'resolution_done')
+  )
+  return log$.unusedOverride.pipe(
+    buffer(resolutionDone$),
+    map((unusedOverrides) => {
+      if (unusedOverrides.length === 0) return Rx.EMPTY
+      const selectors = unusedOverrides
+        .map((log) => sanitizeSelector(log.selector))
+        .sort()
+      const head = selectors.length === 1
+        ? '1 override matched no dependency'
+        : `${selectors.length} overrides matched no dependency`
+      return Rx.of({
+        msg: formatWarn(`${head}: ${selectors.join(', ')}`),
+      })
+    })

Evidence

The reporter buffers every unused override event until resolution_done and then joins all
selectors into a single string, while the installer emits one event per unused selector from the
parsed overrides list (repo-controlled config).

pnpm11/cli/default-reporter/src/reporterForClient/reportUnusedOverrides.ts[25-41]
pnpm11/installing/deps-installer/src/install/index.ts[1662-1680]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`reportUnusedOverrides()` buffers all unused override selectors until `resolution_done` and then builds one giant warning line via `selectors.join(', ')` with no cap. This can create very large allocations and extremely long terminal/CI output when a workspace config contains many or very large override selectors.
### Issue Context
The unused-override events are emitted once per unmatched override selector during install, so the buffered list size scales directly with the configured overrides size.
### Fix Focus Areas
- pnpm11/cli/default-reporter/src/reporterForClient/reportUnusedOverrides.ts[25-41]
- pnpm11/installing/deps-installer/src/install/index.ts[1662-1680]
### Suggested fix direction
- Impose a maximum number of selectors rendered (e.g. first N after sort), and append `… (+X more)`.
- Impose a maximum total message length and/or per-selector length (truncate long selectors).
- Consider deduping identical sanitized selectors before rendering to reduce output volume.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.