feat: notifications say what changed and alert once: a grouped notice names the tracks, grows without re-alerting, and a phone pile lists its titles (M542 #6146-#6151)

- An update to a grouped notice keeps its arrival time and email state, so the
  phone and the email no longer go off again each time it grows.
- Notices carry the names of what changed (newest ten), shown as three and
  "and N more": tracks still missing after the scan's move/replacement fold,
  duplicate groups new to a sweep, songs merged automatically, and the track
  and listener a playback error was for.
- Duplicates found counts only the groups new to that sweep; playback errors
  count reports, not the unresolved total.
- A scan failure says what stopped and links to Admin > Library.
- Android: a pile of more than three alerts lists the newest five titles.

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

internal/db/queries/duplicates.sql

@@ -184,15 +184,25 @@ UPDATE duplicate_groups
    SET status = 'dismissed', resolved_at = now()
  WHERE id = sqlc.arg(id) AND status = 'pending';
 
--- name: CountDuplicateGroupsDetectedSince :one
+-- name: ListDuplicateGroupsDetectedSince :many
 -- 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);
+-- then found for the first time, each named by one of its songs, and `total`
+-- of them however many are listed. A refreshed proposal keeps its detected_at,
+-- so a sweep that only re-finds known groups lists none (M489: admins are told
+-- about new duplicates, not reminded of the same ones every sweep).
+SELECT ar.name AS artist_name, t.title, count(*) OVER ()::bigint AS total
+  FROM duplicate_groups g
+  JOIN LATERAL (SELECT m.track_id
+                  FROM duplicate_group_members m
+                 WHERE m.group_id = g.id
+                 ORDER BY m.track_id
+                 LIMIT 1) one ON true
+  JOIN tracks t ON t.id = one.track_id
+  JOIN artists ar ON ar.id = t.artist_id
+ WHERE g.status = 'pending'
+   AND g.detected_at >= sqlc.arg(since)
+ ORDER BY g.detected_at DESC, g.id
+ LIMIT sqlc.arg(n);
 
 -- name: ListDuplicateGroupsForResolve :many
 -- Every pending group's present copies, for the resolver (M498 #5435): what it

internal/db/queries/notifications.sql

@@ -13,30 +13,29 @@ RETURNING id;
 
 -- name: UpsertCoalescedNotification :one
 -- One unread row per (user, coalesce_key). A new event while that row is
--- unread updates it in place and moves it back to the top of the inbox.
+-- unread updates it in place: its `count` adds to the row's, and its `items`
+-- (the names of what changed) go in front of the row's, keeping the newest
+-- ten. Every coalesced kind's event is "N more happened", never a restated
+-- total, so the row always says what is new since it was last read.
 --
--- sum_count: the payload's `count` adds to the unread row's count rather than
--- replacing it. For kinds whose event is "N more happened" (tracks marked
--- missing). Kinds whose event states the whole current total (pending
--- duplicate groups) pass false and the payload simply replaces.
---
--- emailed_at is cleared so the newer state goes out in the next batch; an
--- emailed-but-unread row that keeps growing is news the user hasn't seen.
--- Unless email_wanted is false, as in InsertNotification.
+-- created_at and emailed_at are left alone (M542): an update changes what the
+-- notice says, not when it arrived. Moving created_at made the phone announce
+-- it again and clearing emailed_at sent it again, so a notice the hourly
+-- duplicate pass kept growing alerted every hour.
 INSERT INTO user_notifications (user_id, kind, payload, coalesce_key, emailed_at)
 VALUES (sqlc.arg(user_id), sqlc.arg(kind), sqlc.arg(payload), sqlc.arg(coalesce_key),
         CASE WHEN sqlc.arg(email_wanted)::boolean THEN NULL ELSE now() END)
 ON CONFLICT (user_id, coalesce_key) WHERE read_at IS NULL AND coalesce_key IS NOT NULL
 DO UPDATE SET
-    payload = CASE
-        WHEN sqlc.arg(sum_count)::boolean THEN
-            EXCLUDED.payload || jsonb_build_object('count',
-                COALESCE((user_notifications.payload->>'count')::bigint, 0)
-              + COALESCE((EXCLUDED.payload->>'count')::bigint, 0))
-        ELSE EXCLUDED.payload
-    END,
-    created_at = now(),
-    emailed_at = EXCLUDED.emailed_at
+    payload = EXCLUDED.payload || jsonb_build_object(
+        'count', COALESCE((user_notifications.payload->>'count')::bigint, 0)
+               + COALESCE((EXCLUDED.payload->>'count')::bigint, 0),
+        'items', (SELECT COALESCE(jsonb_agg(e.item ORDER BY e.n), '[]'::jsonb)
+                    FROM jsonb_array_elements(
+                             COALESCE(EXCLUDED.payload->'items', '[]'::jsonb)
+                          || COALESCE(user_notifications.payload->'items', '[]'::jsonb)
+                         ) WITH ORDINALITY AS e(item, n)
+                   WHERE e.n <= 10))
 RETURNING id;
 
 -- name: ListNotifications :many
@@ -65,8 +64,9 @@ UPDATE user_notifications
 -- name: MarkAllNotificationsRead :execrows
 -- up_to, when set, limits it to what existed when the user asked: a "mark
 -- all read" queued offline and replayed later must not mark notices that
--- arrived in between, which the user never saw. A coalesced row updated
--- since then carries a newer created_at, so it stays unread too.
+-- arrived in between, which the user never saw. A coalesced row that grew
+-- since then is marked read with it: it arrived before they asked, and its
+-- growth is a quiet update to a notice they had seen (M542).
 UPDATE user_notifications
    SET read_at = now()
  WHERE user_id = sqlc.arg(user_id)

internal/db/queries/playback_errors.sql

@@ -61,6 +61,3 @@ 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;

internal/db/queries/tracks.sql

@@ -335,3 +335,14 @@ UPDATE tracks
    SET source_verdict = sqlc.arg(verdict)::text, source_verdict_at = now()
  WHERE id = sqlc.arg(id)
    AND source_verdict IS NOT NULL;
+
+-- name: ListStillMissingTrackLabels :many
+-- Which of the tracks a scan marked missing still are once it has adopted
+-- moves and folded replacements (M542): the ones worth telling an admin
+-- about, by name. A quality upgrade folds into its replacement and drops out.
+SELECT ar.name AS artist_name, t.title
+  FROM tracks t
+  JOIN artists ar ON ar.id = t.artist_id
+ WHERE t.id = ANY(sqlc.arg(ids)::uuid[])
+   AND t.missing_since IS NOT NULL
+ ORDER BY ar.name, t.title;