feat(notifications): library health reaches admins, coalesced (#5341)

- A failed scan run sends scan_failed. Each failure adds to the count and
  the notice shows the latest error. A scan cut short by shutdown says
  nothing.
- Marking tracks missing sends tracks_missing with a running count.
- A duplicate sweep that proposes a group it had not proposed before
  sends duplicates_found, counting everything awaiting review. A sweep
  that only re-finds known groups stays quiet, so a read notice isn't
  repeated every sweep (CountDuplicateGroupsDetectedSince).
- A playback-error report sends playback_errors, counting the unresolved
  errors (CountUnresolvedPlaybackErrors).

The library package gets its notifier as a package-level SetNotifier
beside SetEventBus, for the same reason the bus is package-level.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/db/dbq/duplicates.sql.go

@@ -27,6 +27,24 @@ func (q *Queries) AddDuplicateGroupMember(ctx context.Context, arg AddDuplicateG
 	return err
 }
 
+const countDuplicateGroupsDetectedSince = `-- name: CountDuplicateGroupsDetectedSince :one
+SELECT count(*)::bigint
+  FROM duplicate_groups
+ WHERE status = 'pending'
+   AND detected_at >= $1
+`
+
+// Pending proposals first made at or after `since`: what a sweep that started
+// then found for the first time. A refreshed proposal keeps its detected_at,
+// so a sweep that only re-finds known groups counts none (M489: admins are
+// told about new duplicates, not reminded of the same ones every sweep).
+func (q *Queries) CountDuplicateGroupsDetectedSince(ctx context.Context, since pgtype.Timestamptz) (int64, error) {
+	row := q.db.QueryRow(ctx, countDuplicateGroupsDetectedSince, since)
+	var column_1 int64
+	err := row.Scan(&column_1)
+	return column_1, err
+}
+
 const countPendingDuplicateGroups = `-- name: CountPendingDuplicateGroups :one
 SELECT count(*)::bigint
   FROM duplicate_groups g

internal/db/dbq/playback_errors.sql.go

@@ -11,6 +11,17 @@ import (
 	"github.com/jackc/pgx/v5/pgtype"
 )
 
+const countUnresolvedPlaybackErrors = `-- name: CountUnresolvedPlaybackErrors :one
+SELECT count(*)::bigint FROM playback_errors WHERE resolved_at IS NULL
+`
+
+func (q *Queries) CountUnresolvedPlaybackErrors(ctx context.Context) (int64, error) {
+	row := q.db.QueryRow(ctx, countUnresolvedPlaybackErrors)
+	var column_1 int64
+	err := row.Scan(&column_1)
+	return column_1, err
+}
+
 const insertPlaybackError = `-- name: InsertPlaybackError :one
 INSERT INTO playback_errors (track_id, user_id, client_id, kind, detail)
 VALUES ($1, $2, $3, $4, $5)

internal/db/queries/duplicates.sql

@@ -154,3 +154,13 @@ SELECT p.id                  AS group_id,
 UPDATE duplicate_groups
    SET status = 'dismissed', resolved_at = now()
  WHERE id = sqlc.arg(id) AND status = 'pending';
+
+-- name: CountDuplicateGroupsDetectedSince :one
+-- Pending proposals first made at or after `since`: what a sweep that started
+-- then found for the first time. A refreshed proposal keeps its detected_at,
+-- so a sweep that only re-finds known groups counts none (M489: admins are
+-- told about new duplicates, not reminded of the same ones every sweep).
+SELECT count(*)::bigint
+  FROM duplicate_groups
+ WHERE status = 'pending'
+   AND detected_at >= sqlc.arg(since);

internal/db/queries/playback_errors.sql

@@ -61,3 +61,6 @@ UPDATE playback_errors
        resolved_by = $2,
        resolution  = $3
  WHERE track_id = $1 AND resolved_at IS NULL;
+
+-- name: CountUnresolvedPlaybackErrors :one
+SELECT count(*)::bigint FROM playback_errors WHERE resolved_at IS NULL;