From d09875f9308e7ed6f7555d8a6f804093ca3e3423 Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sat, 24 Oct 2026 06:30:37 +0200
Subject: [PATCH 1/4] feat: split joined artist credits by decision, and a
 needs attention page

Implements RFC-015: a per-library decision splits a credit such as
"Ashreveal, Ashish Swargiary" into the artists it names, or keeps it
whole. Every scan applies it again from the stored first-step credits,
no album or track id moves, and favourites follow the parts through the
journal. The "Needs attention" page lists the credits to decide and the
desktop's track categories the server can compute.

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 CLAUDE.md                                     |    4 +-
 Cargo.toml                                    |    4 +
 docs/rfcs/RFC-015-artist-credit-splitting.md  |    4 +-
 .../20261024020000_artist_credit_decision.sql |   64 +
 src/api/attention.rs                          |  126 ++
 src/api/mod.rs                                |   22 +
 src/catalog.rs                                |  322 ++++-
 src/credit_split.rs                           |  411 +++++++
 src/lib.rs                                    |   15 +
 src/services/attention.rs                     |  352 ++++++
 src/services/credit_decisions.rs              |  751 ++++++++++++
 src/services/mod.rs                           |    6 +
 src/tags.rs                                   |    6 +
 tests/credits.rs                              | 1072 +++++++++++++++++
 webapp/e2e/studio-nocturne.spec.ts            |  245 +++-
 webapp/src/api/attention.ts                   |  107 ++
 webapp/src/api/index.ts                       |   19 +
 webapp/src/api/queries.ts                     |   51 +
 webapp/src/components/artist-split.tsx        |   74 ++
 webapp/src/lib/credit-fragments.test.ts       |   33 +
 webapp/src/lib/credit-fragments.ts            |   55 +
 webapp/src/main.tsx                           |   35 +-
 webapp/src/pages/artist-page.tsx              |    7 +
 webapp/src/pages/attention-page.tsx           |  443 +++++++
 webapp/src/state/i18n.tsx                     |   97 ++
 webapp/src/styles/styles.css                  |  140 +++
 26 files changed, 4399 insertions(+), 66 deletions(-)
 create mode 100644 migrations-v2/20261024020000_artist_credit_decision.sql
 create mode 100644 src/api/attention.rs
 create mode 100644 src/credit_split.rs
 create mode 100644 src/services/attention.rs
 create mode 100644 src/services/credit_decisions.rs
 create mode 100644 tests/credits.rs
 create mode 100644 webapp/src/api/attention.ts
 create mode 100644 webapp/src/components/artist-split.tsx
 create mode 100644 webapp/src/lib/credit-fragments.test.ts
 create mode 100644 webapp/src/lib/credit-fragments.ts
 create mode 100644 webapp/src/pages/attention-page.tsx

diff --git a/CLAUDE.md b/CLAUDE.md
index 439af2e2..8bea50c5 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -44,7 +44,7 @@ bun run build                          # webapp first, then cargo — the order
 
 Tests need no service container: `test_app()` builds a `Config` over a `TempDir` and the suite drives the same router `main` serves. FFmpeg and ffprobe must be on `PATH`.
 
-The integration suite is eighteen targets under `tests/`, one per subject — `auth`, `scanner`, `identity`, `catalog`, `subsonic_contract`, `subsonic_browse`, `subsonic_fields`, `subsonic_methods`, `native_api`, `sync`, `media`, `service`, `cli`, `scrobbling`, `enrichment`, `uploads`, `canvas`, `migrations` — nearly all of them sharing `tests/support/mod.rs`. `migrations` is the exception and deliberately so: every other target starts from `test_app()`, which builds its database from nothing, and that is exactly the path an upgrade does not take. It seeds a database at each **released** schema, boots the server on it, and reads the rows back through the services — and it is where anything else that needs a database *behind* this binary belongs, such as proving that a key change reads without migrating and copies the pair aside before it does. `autotests = false`, so each is a target only because `Cargo.toml` declares it: a new file under `tests/` is compiled by nothing until a `[[test]]` entry names it, and the count above is worth checking against that list rather than trusted. `support/mod.rs` is the exception that proves it — shared module code, declared nowhere, a target never. File a new test by the surface it exercises, and check that by what it calls rather than by what its name says.
+The integration suite is nineteen targets under `tests/`, one per subject — `auth`, `scanner`, `identity`, `catalog`, `subsonic_contract`, `subsonic_browse`, `subsonic_fields`, `subsonic_methods`, `native_api`, `sync`, `media`, `service`, `cli`, `scrobbling`, `enrichment`, `credits`, `uploads`, `canvas`, `migrations` — nearly all of them sharing `tests/support/mod.rs`. `migrations` is the exception and deliberately so: every other target starts from `test_app()`, which builds its database from nothing, and that is exactly the path an upgrade does not take. It seeds a database at each **released** schema, boots the server on it, and reads the rows back through the services — and it is where anything else that needs a database *behind* this binary belongs, such as proving that a key change reads without migrating and copies the pair aside before it does. `autotests = false`, so each is a target only because `Cargo.toml` declares it: a new file under `tests/` is compiled by nothing until a `[[test]]` entry names it, and the count above is worth checking against that list rather than trusted. `support/mod.rs` is the exception that proves it — shared module code, declared nowhere, a target never. File a new test by the surface it exercises, and check that by what it calls rather than by what its name says.
 
 `cargo build` works without a client build — `build.rs` embeds a placeholder page when `webapp/dist` is absent. A real `vite build` overwrites it.
 
@@ -60,7 +60,7 @@ The integration suite is eighteen targets under `tests/`, one per subject — `a
 - **404 blurs everything.** A resource that is missing, and one that belongs to another account, answer identically. `ServiceError::Forbidden` maps onto 404 for that reason. Never confirm existence to someone not entitled to it.
 - **SQLite discipline.** WAL, foreign keys, `busy_timeout`. Every mutation takes the process-wide writer gate (`db.writer_guard()`); libraries may scan concurrently but never open independent writers. `NULL` sorts first in SQLite — order explicitly with `NULLS LAST` wherever a missing tag would otherwise jump the queue.
 - **Migrations are immutable once merged.** They are embedded at compile time and checksummed, so editing an applied migration makes the server refuse to start. Schema changes are new dated files under `migrations-v2/`.
-- **Identifiers and time.** Public ids are UUIDs; timestamps are Unix epoch milliseconds. Album and artist ids are *derived* UUIDs (version 8, RFC 9562 §5.8): the identity engine in `src/pid.rs` hashes the tags that name the entity, under the configurable spec `WAVEFLOW_PID_ALBUM`/`WAVEFLOW_PID_ARTIST`, so the same files answer the same ids on a fresh install. Track ids stay drawn at random — six tables cascade off them, and a scan matches a track by path, then by content hash, then by the relocation hint in `track.pid`. That hint is the track spec evaluated over the file's tags, and it stays a hint: it is asked only when the first two have nothing to say — a file both moved and re-encoded — and it moves nothing unless it names exactly one track whose file has genuinely disappeared. Changing `WAVEFLOW_PID_TRACK` drops every stored hint on the next boot: a hint written under one spec must never be compared against a lookup computed under another, because two specs can evaluate to the same string and the hint would then hand a new file an unrelated track's identity. The next ordinary scan writes them back from its skip path, so clearing them costs no rescan — and a track spec change still re-identifies nothing. Changing a spec re-identifies everything it governs: the next boot notices, schedules a full rescan of every library, and album favourites do not survive it.
+- **Identifiers and time.** Public ids are UUIDs; timestamps are Unix epoch milliseconds. Album and artist ids are *derived* UUIDs (version 8, RFC 9562 §5.8): the identity engine in `src/pid.rs` hashes the tags that name the entity, under the configurable spec `WAVEFLOW_PID_ALBUM`/`WAVEFLOW_PID_ARTIST`, so the same files answer the same ids on a fresh install. Track ids stay drawn at random — six tables cascade off them, and a scan matches a track by path, then by content hash, then by the relocation hint in `track.pid`. That hint is the track spec evaluated over the file's tags, and it stays a hint: it is asked only when the first two have nothing to say — a file both moved and re-encoded — and it moves nothing unless it names exactly one track whose file has genuinely disappeared. Changing `WAVEFLOW_PID_TRACK` drops every stored hint on the next boot: a hint written under one spec must never be compared against a lookup computed under another, because two specs can evaluate to the same string and the hint would then hand a new file an unrelated track's identity. The next ordinary scan writes them back from its skip path, so clearing them costs no rescan — and a track spec change still re-identifies nothing. Changing a spec re-identifies everything it governs: the next boot notices, schedules a full rescan of every library, and album favourites do not survive it. A credit decision (RFC-015) is narrower: splitting a joined credit such as `Zedd, Alessia Cara` re-identifies only the artists it names. The album display string and the track hint read the tag mapper's names, before any decision, so no album or track id moves, and favourites on the joined artist are carried onto its parts through the journal.
 - **Credentials.** Web passwords use Argon2id. Access, refresh, API and OAuth codes are stored as SHA-256 hashes only. The dedicated Subsonic password is encrypted with ChaCha20-Poly1305 under the instance key. Back up `data/waveflow.db` and `data/instance.key` together — encrypted values cannot be recovered with one without the other.
 - **Browser playback uses stream tickets** (`src/stream_ticket.rs`). `<audio src>` cannot send an `Authorization` header, so the client exchanges its session for an AEAD-sealed `(user, track, expiry)` and plays from `/api/v2/stream/{ticket}`. Access is re-checked on every redemption, so a ticket cannot outlive the membership that justified it. The TTL is an hour rather than seconds because the browser reuses that URL for every range request while seeking.
 - **Native clients use Authorization Code + PKCE** (`src/oauth.rs`). S256 only; redirect targets restricted to loopback, https or a reverse-domain private scheme. A code is spent by its first presentation whatever the outcome.
diff --git a/Cargo.toml b/Cargo.toml
index 2906a04d..41ff6ec1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -168,3 +168,7 @@ path = "tests/scrobbling.rs"
 [[test]]
 name = "enrichment"
 path = "tests/enrichment.rs"
+
+[[test]]
+name = "credits"
+path = "tests/credits.rs"
diff --git a/docs/rfcs/RFC-015-artist-credit-splitting.md b/docs/rfcs/RFC-015-artist-credit-splitting.md
index 0d4b39b8..91f956c6 100644
--- a/docs/rfcs/RFC-015-artist-credit-splitting.md
+++ b/docs/rfcs/RFC-015-artist-credit-splitting.md
@@ -416,7 +416,7 @@ its category at once. Only available tracks are counted.
 | `missing_track_number` | effective track number `NULL` or `<= 0` |
 | `missing_cover` | neither the track nor its album has artwork |
 | `album_year_conflict` | its album's available tracks carry more than one non-zero effective year |
-| `compilation_no_album_artist` | flagged a compilation, and the file names no album artist (it was filed under `Various Artists` by the fallback) |
+| `compilation_no_album_artist` | its album is flagged a compilation and its album artist is `Various Artists`. That is the fallback for a compilation whose files name no album artist, and the server cannot tell it from a file that writes those words itself, so both are listed |
 | `duplicate_track_number` | another track of the same album has the same `COALESCE(disc, 1)` and the same number `> 0` |
 | `track_number_gap` | on its disc, `MAX - MIN + 1 > COUNT(DISTINCT number)` |
 | `probable_duplicate` | same normalised title and same credited artists, durations chained within 2 seconds. This reuses `waveflow_core::metadata::name_match::normalize_name` and `waveflow_core::inventory::chain_by_duration`, both public at the pinned revision |
@@ -451,7 +451,7 @@ caller is not an owner or manager of, and for an id not in it.
 | --- | --- |
 | `GET /libraries/{id}/attention` | `[{ category, count }]` for `split_credits` and each track category, in display order. |
 | `GET /libraries/{id}/attention/credits` | The candidates of decision 8, sorted as stated, with their fragments. |
-| `GET /libraries/{id}/attention/tracks?category=&offset=&limit=` | The tracks in one category, as the song items `GET /libraries/{id}/tracks` already returns. `probable_duplicate` adds a group key to each item, so a client can draw the groups. `422` for an unknown category. |
+| `GET /libraries/{id}/attention/tracks?category=&offset=&limit=` | The tracks in one category, as the song items `GET /libraries/{id}/tracks` already returns. `probable_duplicate` adds `duplicate_group`, numbered from one, to each item, so a client can draw the groups. `422` for an unknown category. |
 | `GET /libraries/{id}/credit-decisions` | The decisions, newest first: id, credit, decision, parts, who and when. |
 | `POST /libraries/{id}/credit-decisions` | `{ "artist_id": …, "decision": "split" \| "keep" }`. The artist must be a candidate. A split takes its fragments as decision 2 computes them now, and the server stores them. `201` with the decision. `409` when the credit already has one (remove it first). `422` for an artist that is not a candidate. |
 | `DELETE /libraries/{id}/credit-decisions/{decision_id}` | Decision 7. `204`. |
diff --git a/migrations-v2/20261024020000_artist_credit_decision.sql b/migrations-v2/20261024020000_artist_credit_decision.sql
new file mode 100644
index 00000000..f7e60908
--- /dev/null
+++ b/migrations-v2/20261024020000_artist_credit_decision.sql
@@ -0,0 +1,64 @@
+-- Splitting a joined artist credit, by decision (RFC-015).
+--
+-- A comma is not a separator the scanner may cut on by itself: `Tyler, The
+-- Creator` is one artist and `Zedd, Alessia Cara` is two, and nothing in the
+-- tags says which. So a person decides, once per library, and the decision is
+-- a row every scan reads back — which is what the desktop's own list never
+-- had, and why its splits came undone whenever a file changed.
+
+-- One decision per credit and library. The key is the credit folded the way
+-- the artist identity folds a name (lower case, then `pid::str_clear`), so it
+-- names exactly the spellings that make one artist row, and it survives a
+-- change of `WAVEFLOW_PID_ARTIST` that an artist id would not.
+--
+-- `parts` holds the fragments as they were shown and accepted, so a recorded
+-- split keeps its meaning if the fragment rule ever changes. `decided_by` is an
+-- account id without a foreign key, as `artist_image_choice.set_by` is: an
+-- account removed later does not take the library's decision with it.
+CREATE TABLE artist_credit_decision (
+    id TEXT PRIMARY KEY NOT NULL,
+    library_id TEXT NOT NULL REFERENCES library(id) ON DELETE CASCADE,
+    credit_key TEXT NOT NULL CHECK (length(credit_key) > 0),
+    credit TEXT NOT NULL CHECK (length(trim(credit)) > 0),
+    decision TEXT NOT NULL CHECK (decision IN ('split', 'keep')),
+    parts TEXT CHECK (
+        (decision = 'split' AND json_type(parts) = 'array')
+        OR (decision = 'keep' AND parts IS NULL)),
+    decided_by TEXT NOT NULL,
+    decided_at INTEGER NOT NULL,
+    UNIQUE (library_id, credit_key)
+) STRICT;
+
+-- The credits as the tag mapper produced them, before any decision: what a
+-- decision is applied to, and what an undo goes back to. The participants
+-- became a function of this table and of the decisions, so taking or removing
+-- a decision needs no file read, and two credits sharing a part (`A, B` and
+-- `A, C`) keep the file's order whichever is undone first.
+--
+-- Positions are per role, across sub-roles, as in `track_participant`: the
+-- performers of one track are numbered in one sequence whatever their
+-- instruments.
+CREATE TABLE track_credit (
+    track_id TEXT NOT NULL,
+    library_id TEXT NOT NULL,
+    role TEXT NOT NULL CHECK (length(trim(role)) > 0),
+    sub_role TEXT NOT NULL DEFAULT '',
+    position INTEGER NOT NULL CHECK (position >= 0),
+    name TEXT NOT NULL CHECK (length(trim(name)) > 0),
+    sort_name TEXT,
+    PRIMARY KEY (track_id, role, position),
+    FOREIGN KEY (track_id, library_id)
+        REFERENCES track(id, library_id) ON DELETE CASCADE
+) STRICT;
+
+-- No decision exists yet, so the credits are what the participants already
+-- say. The copy loses only a later credit naming the same artist as an earlier
+-- one, which the participants never held and which the computation would drop
+-- again by keeping the first occurrence; the next scan of that file writes it
+-- back. Under a correction the copied `artist` rows are the corrected list
+-- rather than the file's, which nothing reads while the correction stands, and
+-- removing a correction re-reads the file. So no rescan is scheduled.
+INSERT INTO track_credit (track_id, library_id, role, sub_role, position, name, sort_name)
+SELECT tp.track_id, tp.library_id, tp.role, tp.sub_role, tp.position, ar.name, tp.sort_name
+  FROM track_participant tp
+  JOIN artist ar ON ar.id = tp.artist_id;
diff --git a/src/api/attention.rs b/src/api/attention.rs
new file mode 100644
index 00000000..33121f47
--- /dev/null
+++ b/src/api/attention.rs
@@ -0,0 +1,126 @@
+//! "Needs attention" and credit decisions (RFC-015).
+//!
+//! Handlers orchestrate HTTP only; the rules live in `DomainServices`. Every
+//! route here is for a library's owners and managers, and everyone else gets
+//! the same `404` a library they are not in would.
+
+use super::*;
+
+#[derive(Debug, Deserialize)]
+pub struct AttentionTracksQuery {
+    pub category: String,
+    pub offset: Option<i64>,
+    pub limit: Option<i64>,
+}
+
+#[derive(Debug, Deserialize, ToSchema)]
+pub struct CreditDecisionRequest {
+    /// An artist the candidates listed: the credit it makes is what is decided.
+    pub artist_id: Uuid,
+    pub decision: crate::services::CreditDecisionKind,
+}
+
+/// How many items each list of the page holds, in display order.
+#[utoipa::path(get, path = "/api/v2/libraries/{library_id}/attention", tag = "catalog", params(("library_id" = Uuid, Path)), responses((status = 200, body = [crate::services::AttentionCount]), (status = 401, body = ErrorResponse), (status = 404, body = ErrorResponse)))]
+pub async fn attention_summary(
+    State(state): State<AppState>,
+    Path(library_id): Path<Uuid>,
+    headers: HeaderMap,
+) -> Result<Json<Vec<crate::services::AttentionCount>>, ApiError> {
+    let user = authenticated(&state, &headers, Access::Read).await?;
+    state
+        .services
+        .attention_summary(user.id, library_id)
+        .await
+        .map(Json)
+        .map_err(service_error)
+}
+
+/// The joined credits waiting for a decision, each with its fragments.
+#[utoipa::path(get, path = "/api/v2/libraries/{library_id}/attention/credits", tag = "catalog", params(("library_id" = Uuid, Path)), responses((status = 200, body = [crate::services::CreditCandidate]), (status = 401, body = ErrorResponse), (status = 404, body = ErrorResponse)))]
+pub async fn attention_credits(
+    State(state): State<AppState>,
+    Path(library_id): Path<Uuid>,
+    headers: HeaderMap,
+) -> Result<Json<Vec<crate::services::CreditCandidate>>, ApiError> {
+    let user = authenticated(&state, &headers, Access::Read).await?;
+    state
+        .services
+        .credit_candidates(user.id, library_id)
+        .await
+        .map(Json)
+        .map_err(service_error)
+}
+
+/// One page of the tracks in one category. `422` for a category that is not
+/// a track category.
+#[utoipa::path(get, path = "/api/v2/libraries/{library_id}/attention/tracks", tag = "catalog", params(("library_id" = Uuid, Path), ("category" = String, Query), ("offset" = Option<i64>, Query), ("limit" = Option<i64>, Query)), responses((status = 200, body = [crate::services::AttentionTrack]), (status = 401, body = ErrorResponse), (status = 404, body = ErrorResponse), (status = 422, body = ErrorResponse)))]
+pub async fn attention_tracks(
+    State(state): State<AppState>,
+    Path(library_id): Path<Uuid>,
+    Query(query): Query<AttentionTracksQuery>,
+    headers: HeaderMap,
+) -> Result<Json<Vec<crate::services::AttentionTrack>>, ApiError> {
+    let user = authenticated(&state, &headers, Access::Read).await?;
+    let category = crate::services::AttentionCategory::parse_track_category(&query.category)
+        .ok_or(ApiError::Validation)?;
+    let page =
+        crate::services::BrowsePage::new(query.offset, query.limit).map_err(service_error)?;
+    state
+        .services
+        .attention_tracks(user.id, library_id, category, page)
+        .await
+        .map(Json)
+        .map_err(service_error)
+}
+
+/// The library's decisions, newest first.
+#[utoipa::path(get, path = "/api/v2/libraries/{library_id}/credit-decisions", tag = "catalog", params(("library_id" = Uuid, Path)), responses((status = 200, body = [crate::services::CreditDecisionRecord]), (status = 401, body = ErrorResponse), (status = 404, body = ErrorResponse)))]
+pub async fn list_credit_decisions(
+    State(state): State<AppState>,
+    Path(library_id): Path<Uuid>,
+    headers: HeaderMap,
+) -> Result<Json<Vec<crate::services::CreditDecisionRecord>>, ApiError> {
+    let user = authenticated(&state, &headers, Access::Read).await?;
+    state
+        .services
+        .credit_decisions(user.id, library_id)
+        .await
+        .map(Json)
+        .map_err(service_error)
+}
+
+/// Splits a joined credit or keeps it whole, and applies that at once. `409`
+/// when the credit already has a decision, `422` for an artist that is not a
+/// candidate.
+#[utoipa::path(post, path = "/api/v2/libraries/{library_id}/credit-decisions", tag = "catalog", params(("library_id" = Uuid, Path)), request_body = CreditDecisionRequest, responses((status = 201, body = crate::services::CreditDecisionRecord), (status = 401, body = ErrorResponse), (status = 404, body = ErrorResponse), (status = 409, body = ErrorResponse), (status = 422, body = ErrorResponse)))]
+pub async fn create_credit_decision(
+    State(state): State<AppState>,
+    Path(library_id): Path<Uuid>,
+    headers: HeaderMap,
+    Json(request): Json<CreditDecisionRequest>,
+) -> Result<(StatusCode, Json<crate::services::CreditDecisionRecord>), ApiError> {
+    let user = authenticated(&state, &headers, Access::Write).await?;
+    state
+        .services
+        .decide_credit(user.id, library_id, request.artist_id, request.decision)
+        .await
+        .map(|decision| (StatusCode::CREATED, Json(decision)))
+        .map_err(service_error)
+}
+
+/// Removes a decision and restores what the library holds without it.
+#[utoipa::path(delete, path = "/api/v2/libraries/{library_id}/credit-decisions/{decision_id}", tag = "catalog", params(("library_id" = Uuid, Path), ("decision_id" = Uuid, Path)), responses((status = 204), (status = 401, body = ErrorResponse), (status = 404, body = ErrorResponse)))]
+pub async fn delete_credit_decision(
+    State(state): State<AppState>,
+    Path((library_id, decision_id)): Path<(Uuid, Uuid)>,
+    headers: HeaderMap,
+) -> Result<StatusCode, ApiError> {
+    let user = authenticated(&state, &headers, Access::Write).await?;
+    state
+        .services
+        .remove_credit_decision(user.id, library_id, decision_id)
+        .await
+        .map(|()| StatusCode::NO_CONTENT)
+        .map_err(service_error)
+}
diff --git a/src/api/mod.rs b/src/api/mod.rs
index 8b88c56c..91c4f77a 100644
--- a/src/api/mod.rs
+++ b/src/api/mod.rs
@@ -23,6 +23,7 @@ use uuid::Uuid;
 use crate::{authentication::AuthError, AppState};
 
 pub(crate) mod access;
+mod attention;
 mod auth;
 mod bookmarks;
 mod catalog;
@@ -47,6 +48,7 @@ mod users;
 mod web_session;
 
 pub(crate) use access::*;
+pub use attention::*;
 pub use auth::*;
 pub use bookmarks::*;
 pub use catalog::*;
@@ -134,6 +136,26 @@ pub fn router(state: AppState) -> Router {
             "/api/v2/folders/{folder_id}",
             axum::routing::patch(update_folder).delete(delete_folder),
         )
+        .route(
+            "/api/v2/libraries/{library_id}/attention",
+            get(attention_summary),
+        )
+        .route(
+            "/api/v2/libraries/{library_id}/attention/credits",
+            get(attention_credits),
+        )
+        .route(
+            "/api/v2/libraries/{library_id}/attention/tracks",
+            get(attention_tracks),
+        )
+        .route(
+            "/api/v2/libraries/{library_id}/credit-decisions",
+            get(list_credit_decisions).post(create_credit_decision),
+        )
+        .route(
+            "/api/v2/libraries/{library_id}/credit-decisions/{decision_id}",
+            delete(delete_credit_decision),
+        )
         .route("/api/v2/libraries/{library_id}/events", get(library_events))
         .route(
             "/api/v2/libraries/{library_id}/events/ack",
diff --git a/src/catalog.rs b/src/catalog.rs
index 2d581733..e01f4bd6 100644
--- a/src/catalog.rs
+++ b/src/catalog.rs
@@ -1176,32 +1176,30 @@ impl Database {
         // where identity is written: the test suite applies catalogue rows
         // directly, and reading the tag values one way there and another way
         // in production is how the two drift apart.
-        let credits = track_credits(input);
+        //
+        // These are the first step's credits (RFC-015): what the tags say,
+        // before any decision. They are stored as they are, and everything an
+        // identity hangs off — the album's display string, the relocation
+        // hint — reads them rather than what the decisions make of them, so a
+        // split never moves an album id.
+        let file_credits = with_album_artist_sorts(track_credits(input));
         let moved = apply.moved;
         let track_id = existing_id.unwrap_or_else(Uuid::new_v4);
         // A track that already exists may carry corrections, and a scan must
         // not undo them. Only its own `artist` credits are displaced: a
         // composer or a conductor comes from the file and nobody corrected it.
         let overrides = track_override_lists(tx, track_id).await?;
-        let credits = match &overrides.artists {
-            None => credits,
-            Some(names) => {
-                let mut kept: Vec<crate::tags::Credit> = credits
-                    .into_iter()
-                    .filter(|credit| credit.role != crate::tags::Role::Artist)
-                    .collect();
-                for (position, name) in names.iter().enumerate() {
-                    kept.push(crate::tags::Credit {
-                        role: crate::tags::Role::Artist,
-                        sub_role: String::new(),
-                        name: name.clone(),
-                        sort_name: None,
-                        position,
-                    });
-                }
-                kept
-            }
-        };
+        // Read inside the transaction that writes the batch, so a decision
+        // taken while a scan runs is either before this batch, which applies
+        // it, or after it, in which case the decision's own pass finds what
+        // this batch wrote.
+        let decisions = credit_decisions(tx, library_id).await?;
+        let credits = crate::credit_split::resolve(
+            &file_credits,
+            &decisions,
+            overrides.artists.as_deref(),
+            |name| pid.artist_id(library_id, name.trim()),
+        );
         // The display strings follow the correction too, or a track would read
         // one way in a listing and another in its own row.
         // An empty correction says the track credits nobody, which is absence
@@ -1222,7 +1220,9 @@ impl Database {
         }
         let album_artist_names: Vec<String> =
             credit_names(&credits, crate::tags::Role::AlbumArtist);
-        let album_artist = album_artist_display(input, &credits);
+        // The first step's names, not the decisions': the display string is
+        // what the album's identity hashes (RFC-015 decision 4).
+        let album_artist = album_artist_display(input, &file_credits);
         let mut album_artist_ids = Vec::with_capacity(album_artist_names.len());
         for name in &album_artist_names {
             album_artist_ids.push(upsert_artist(tx, pid, library_id, name, now).await?);
@@ -1231,27 +1231,6 @@ impl Database {
         // that is the first credit. The rest reach clients through the album's
         // participants rather than through this column.
         let album_artist_id = album_artist_ids.first().copied();
-        // The sort form of each credit *on this track*. A credit the track tag
-        // says nothing about falls back to the album artist tag when the two
-        // name the same artist — ALBUMARTISTSORT is the more commonly written
-        // of the two, and matching on the name rather than on position means
-        // this cannot file one artist under another's sort form.
-        let credit_sorts = {
-            let track_sorts = credit_sort_names(&credits, crate::tags::Role::Artist);
-            let album_sorts = credit_sort_names(&credits, crate::tags::Role::AlbumArtist);
-            artist_names
-                .iter()
-                .zip(track_sorts)
-                .map(|(name, sort)| {
-                    sort.or_else(|| {
-                        album_artist_names
-                            .iter()
-                            .position(|candidate| candidate == name)
-                            .and_then(|at| album_sorts.get(at).cloned().flatten())
-                    })
-                })
-                .collect::<Vec<_>>()
-        };
         let album = upsert_album(
             tx,
             pid,
@@ -1389,6 +1368,7 @@ impl Database {
             .await?;
         }
 
+        write_track_credits(tx, library_id, track_id, &file_credits).await?;
         // Every credit the file names, not just its artists. The delete comes
         // first for the reason the reference gives: an artist who was both an
         // album artist and a composer, and is now only a composer, has to lose
@@ -1409,10 +1389,7 @@ impl Database {
                     .expect("every album-artist credit was upserted above"),
                 _ => upsert_artist(tx, pid, library_id, &credit.name, now).await?,
             };
-            let sort_name = match credit.role {
-                crate::tags::Role::Artist => credit_sorts.get(credit.position).cloned().flatten(),
-                _ => credit.sort_name.clone(),
-            };
+            let sort_name = credit.sort_name.clone();
             // A file can credit the same artist twice under one role — two
             // spellings folding onto one row — and the second insert would
             // then collide on the key. The first credit wins, as it does in
@@ -2295,19 +2272,254 @@ fn credits_in_role(
     named
 }
 
-fn credit_names(credits: &[crate::tags::Credit], role: crate::tags::Role) -> Vec<String> {
-    credits_in_role(credits, role)
-        .iter()
-        .map(|credit| credit.name.clone())
-        .collect()
+/// The sort form of each artist credit *on this track*. A credit the track
+/// tag says nothing about falls back to the album artist tag when the two name
+/// the same artist — ALBUMARTISTSORT is the more commonly written of the two,
+/// and matching on the name rather than on position means this cannot file one
+/// artist under another's sort form.
+///
+/// Applied to the first step's credits, before they are stored, so
+/// `track_credit` holds the sort form a participant gets and a decision splits
+/// the same one a scan would.
+fn with_album_artist_sorts(mut credits: Vec<crate::tags::Credit>) -> Vec<crate::tags::Credit> {
+    let album: Vec<(String, Option<String>)> =
+        credits_in_role(&credits, crate::tags::Role::AlbumArtist)
+            .iter()
+            .map(|credit| (credit.name.clone(), credit.sort_name.clone()))
+            .collect();
+    for credit in credits
+        .iter_mut()
+        .filter(|credit| credit.role == crate::tags::Role::Artist && credit.sort_name.is_none())
+    {
+        credit.sort_name = album
+            .iter()
+            .find(|(name, _)| *name == credit.name)
+            .and_then(|(_, sort)| sort.clone());
+    }
+    credits
+}
+
+/// A library's credit decisions (RFC-015), by key.
+///
+/// A row whose parts no longer decode is read as no decision rather than
+/// failing the scan that reads it: the one writer stores a `Vec<String>`, and
+/// a credit left whole is what the library had before anyone decided.
+pub(crate) async fn credit_decisions(
+    tx: &mut Transaction<'_, Sqlite>,
+    library_id: Uuid,
+) -> Result<crate::credit_split::Decisions, sqlx::Error> {
+    let rows = sqlx::query(
+        "SELECT credit_key, decision, parts FROM artist_credit_decision WHERE library_id = ?",
+    )
+    .bind(library_id.to_string())
+    .fetch_all(&mut **tx)
+    .await?;
+    let mut decisions = crate::credit_split::Decisions::new();
+    for row in rows {
+        let key: String = row.try_get("credit_key")?;
+        let decision = match row.try_get::<&str, _>("decision")? {
+            "keep" => crate::credit_split::CreditDecision::Keep,
+            _ => {
+                let parts: Option<String> = row.try_get("parts")?;
+                match parts.and_then(|parts| serde_json::from_str::<Vec<String>>(&parts).ok()) {
+                    Some(parts) => crate::credit_split::CreditDecision::Split(parts),
+                    None => continue,
+                }
+            }
+        };
+        decisions.insert(key, decision);
+    }
+    Ok(decisions)
 }
 
-fn credit_sort_names(
+/// Stores a track's first-step credits, replacing what it held.
+pub(crate) async fn write_track_credits(
+    tx: &mut Transaction<'_, Sqlite>,
+    library_id: Uuid,
+    track_id: Uuid,
     credits: &[crate::tags::Credit],
-    role: crate::tags::Role,
-) -> Vec<Option<String>> {
+) -> Result<(), sqlx::Error> {
+    sqlx::query("DELETE FROM track_credit WHERE track_id = ?")
+        .bind(track_id.to_string())
+        .execute(&mut **tx)
+        .await?;
+    for credit in credits {
+        // `OR IGNORE`: a position is unique per role by construction, and the
+        // one thing that could repeat it — two groups of one role — the tag
+        // mapper already merges. Failing a whole scan batch on it would cost
+        // more than the duplicate credit it would protect.
+        sqlx::query(
+            "INSERT OR IGNORE INTO track_credit                (track_id, library_id, role, sub_role, position, name, sort_name)              VALUES (?, ?, ?, ?, ?, ?, ?)",
+        )
+        .bind(track_id.to_string())
+        .bind(library_id.to_string())
+        .bind(credit.role.as_str())
+        .bind(&credit.sub_role)
+        .bind(credit.position as i64)
+        .bind(credit.name.trim())
+        .bind(credit.sort_name.as_deref())
+        .execute(&mut **tx)
+        .await?;
+    }
+    Ok(())
+}
+
+/// A track's stored first-step credits, in role and position order.
+pub(crate) async fn read_track_credits(
+    tx: &mut Transaction<'_, Sqlite>,
+    track_id: Uuid,
+) -> Result<Vec<crate::tags::Credit>, sqlx::Error> {
+    let rows = sqlx::query(
+        "SELECT role, sub_role, position, name, sort_name FROM track_credit          WHERE track_id = ? ORDER BY role, position",
+    )
+    .bind(track_id.to_string())
+    .fetch_all(&mut **tx)
+    .await?;
+    let mut credits = Vec::with_capacity(rows.len());
+    for row in rows {
+        // A role this binary does not know was written by a newer one; it is
+        // left out rather than guessed, as `track_participant` leaves it.
+        let Some(role) = crate::tags::Role::parse(row.try_get::<&str, _>("role")?) else {
+            continue;
+        };
+        credits.push(crate::tags::Credit {
+            role,
+            sub_role: row.try_get("sub_role")?,
+            name: row.try_get("name")?,
+            sort_name: row.try_get("sort_name")?,
+            position: row.try_get::<i64, _>("position")?.max(0) as usize,
+        });
+    }
+    Ok(credits)
+}
+
+/// What recomputing one track's participants did.
+#[derive(Debug, Clone)]
+pub(crate) struct Recomputed {
+    pub changed: bool,
+    pub album_id: Option<Uuid>,
+    pub full_hash: String,
+}
+
+/// Recomputes one track's participants from its stored credits and the
+/// library's decisions (RFC-015 decision 5), with no file read.
+///
+/// The same function a scan calls, over the same inputs, so a decision taken
+/// now and a rescan later end in identical rows. Nothing is written when the
+/// result is what the track already holds: a pass over a track the decision
+/// does not change touches no row, records no event and leaves no artist
+/// behind.
+pub(crate) async fn recompute_track_participants(
+    tx: &mut Transaction<'_, Sqlite>,
+    pid: &crate::pid::PidSpecs,
+    library_id: Uuid,
+    track_id: Uuid,
+    decisions: &crate::credit_split::Decisions,
+    now: i64,
+) -> Result<Recomputed, sqlx::Error> {
+    let row = sqlx::query("SELECT album_id, full_hash, artist_display FROM track WHERE id = ?")
+        .bind(track_id.to_string())
+        .fetch_one(&mut **tx)
+        .await?;
+    let album_id = row
+        .try_get::<Option<String>, _>("album_id")?
+        .map(parse_uuid)
+        .transpose()?;
+    let full_hash: String = row.try_get("full_hash")?;
+    let artist_display: Option<String> = row.try_get("artist_display")?;
+
+    let file_credits = read_track_credits(tx, track_id).await?;
+    let overrides = track_override_lists(tx, track_id).await?;
+    let credits = crate::credit_split::resolve(
+        &file_credits,
+        decisions,
+        overrides.artists.as_deref(),
+        |name| pid.artist_id(library_id, name.trim()),
+    );
+    let mut desired: Vec<(String, String, String, i64, Option<String>)> = credits
+        .iter()
+        .map(|credit| {
+            (
+                credit.role.as_str().to_owned(),
+                pid.artist_id(library_id, credit.name.trim()).to_string(),
+                credit.sub_role.clone(),
+                credit.position as i64,
+                credit.sort_name.clone(),
+            )
+        })
+        .collect();
+    desired.sort_by(|left, right| (&left.0, left.3).cmp(&(&right.0, right.3)));
+    let current: Vec<(String, String, String, i64, Option<String>)> = sqlx::query_as(
+        "SELECT role, artist_id, sub_role, position, sort_name FROM track_participant          WHERE track_id = ? ORDER BY role, position",
+    )
+    .bind(track_id.to_string())
+    .fetch_all(&mut **tx)
+    .await?;
+    if current == desired {
+        return Ok(Recomputed {
+            changed: false,
+            album_id,
+            full_hash,
+        });
+    }
+
+    sqlx::query("DELETE FROM track_participant WHERE track_id = ?")
+        .bind(track_id.to_string())
+        .execute(&mut **tx)
+        .await?;
+    let mut first_album_artist = None;
+    for credit in &credits {
+        let artist_id = upsert_artist(tx, pid, library_id, &credit.name, now).await?;
+        if credit.role == crate::tags::Role::AlbumArtist && first_album_artist.is_none() {
+            first_album_artist = Some(artist_id);
+        }
+        sqlx::query(
+            "INSERT INTO track_participant                (track_id, artist_id, library_id, role, sub_role, position, sort_name)              VALUES (?, ?, ?, ?, ?, ?, ?)              ON CONFLICT (track_id, artist_id, role, sub_role) DO NOTHING",
+        )
+        .bind(track_id.to_string())
+        .bind(artist_id.to_string())
+        .bind(library_id.to_string())
+        .bind(credit.role.as_str())
+        .bind(&credit.sub_role)
+        .bind(credit.position as i64)
+        .bind(credit.sort_name.as_deref())
+        .execute(&mut **tx)
+        .await?;
+    }
+    // The album hangs off its first credited artist, as the scan's upsert
+    // writes it; the display string, and with it the album's id, stay what
+    // the file said.
+    if let (Some(album), Some(artist)) = (album_id, first_album_artist) {
+        sqlx::query("UPDATE album SET album_artist_id = ?, updated_at = ? WHERE id = ?")
+            .bind(artist.to_string())
+            .bind(now)
+            .bind(album.to_string())
+            .execute(&mut **tx)
+            .await?;
+    }
+    // The search index holds every credited name, as the scan writes it, so
+    // a split track is found under each part and no longer under the whole.
+    let mut names: Vec<&str> = credits.iter().map(|credit| credit.name.as_str()).collect();
+    names.sort_unstable();
+    names.dedup();
+    if let Some(display) = artist_display.as_deref() {
+        names.push(display);
+    }
+    sqlx::query("UPDATE track_fts SET artists = ? WHERE track_id = ?")
+        .bind(names.join(" "))
+        .bind(track_id.to_string())
+        .execute(&mut **tx)
+        .await?;
+    Ok(Recomputed {
+        changed: true,
+        album_id,
+        full_hash,
+    })
+}
+
+fn credit_names(credits: &[crate::tags::Credit], role: crate::tags::Role) -> Vec<String> {
     credits_in_role(credits, role)
         .iter()
-        .map(|credit| credit.sort_name.clone())
+        .map(|credit| credit.name.clone())
         .collect()
 }
diff --git a/src/credit_split.rs b/src/credit_split.rs
new file mode 100644
index 00000000..b0c2a581
--- /dev/null
+++ b/src/credit_split.rs
@@ -0,0 +1,411 @@
+//! Splitting a joined artist credit, by decision (RFC-015).
+//!
+//! The tag mapper (`crate::tags`) cuts an artist value on the separators no
+//! band name carries. A comma is not one of them — `Tyler, The Creator` is one
+//! artist, `Zedd, Alessia Cara` two — so a credit holding one is left whole,
+//! and an owner decides. This is the second step, applied to each name the
+//! first one produced:
+//!
+//! ```text
+//! tag value ── tags::credits ──▶ credit names ── decisions ──▶ participants
+//! ```
+//!
+//! Everything here is pure: a name, its sort form and the library's decisions
+//! in, names out. That is what lets a decision be applied to the stored
+//! catalogue without reading a file, and what makes a scan and an immediate
+//! split end in the same rows — they call the same function.
+
+use std::collections::{HashMap, HashSet};
+
+use uuid::Uuid;
+
+use crate::tags::{Credit, Role};
+
+/// The characters a joined credit is cut on: the desktop's set, ASCII and
+/// fullwidth commas and the two ideographic ones. Unpadded, as the desktop's
+/// cut is, so `蔡依林，周杰伦` splits.
+pub const FRAGMENT_SEPARATORS: [char; 4] = [',', '，', '、', '､'];
+
+/// The key a decision is stored under: the name folded the way the artist
+/// identity folds it, so one key names exactly the spellings that make one
+/// artist row under the default spec — and survives a change of spec, which
+/// an artist id would not.
+pub fn credit_key(name: &str) -> String {
+    crate::pid::str_clear(&name.trim().to_lowercase())
+}
+
+/// The name cut on [`FRAGMENT_SEPARATORS`], never inside parentheses, trimmed,
+/// blanks dropped — and duplicates kept, because a sort form is paired with
+/// this list position by position before anything is deduplicated.
+///
+/// The parenthesis rule is the tag mapper's (`tags::split_on`): a comma inside
+/// one qualifies a name rather than dividing two, so `Ian Asher, Olly Alexander
+/// (Years & Years)` is two artists and not three fragments.
+fn cut(value: &str) -> Vec<String> {
+    let mut parts = Vec::new();
+    let mut depth: usize = 0;
+    let mut current = String::new();
+    for character in value.chars() {
+        match character {
+            '(' => depth += 1,
+            ')' => depth = depth.saturating_sub(1),
+            _ => {}
+        }
+        if depth == 0 && FRAGMENT_SEPARATORS.contains(&character) {
+            parts.push(std::mem::take(&mut current));
+        } else {
+            current.push(character);
+        }
+    }
+    parts.push(current);
+    parts
+        .into_iter()
+        .map(|part| part.trim().to_owned())
+        .filter(|part| !part.is_empty())
+        .collect()
+}
+
+fn canonical(name: &str) -> String {
+    waveflow_core::scanner::canonical_name(name)
+}
+
+/// What a split of `name` would credit: the cut, deduplicated on the canonical
+/// name with the first spelling kept.
+pub fn fragments(name: &str) -> Vec<String> {
+    let mut seen = HashSet::new();
+    cut(name)
+        .into_iter()
+        .filter(|part| seen.insert(canonical(part)))
+        .collect()
+}
+
+/// Whether `name` is a credit an owner may be asked about: at least two
+/// fragments, none of them the whole credit again. `Solo,` never is.
+pub fn is_candidate(name: &str) -> bool {
+    let parts = fragments(name);
+    let whole = canonical(name);
+    parts.len() >= 2 && parts.iter().all(|part| canonical(part) != whole)
+}
+
+/// What a library decided about one credit.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CreditDecision {
+    /// Replaced, wherever it is credited, by these names in this order.
+    Split(Vec<String>),
+    /// Left whole. It changes nothing a scan writes; it is what takes the
+    /// credit off the list.
+    Keep,
+}
+
+/// A library's decisions, by [`credit_key`].
+pub type Decisions = HashMap<String, CreditDecision>;
+
+/// The parts a split credit is replaced by on one track, each with the sort
+/// form this track's tags paired with it.
+///
+/// The sort form is cut by the same rule and paired with the track's own
+/// fragments **before** they are deduplicated, all or nothing as
+/// `tags::paired_sorts` pairs a joined tag. Pairing after the deduplication
+/// would compare `A, B, B, C` — three names — with four sort forms, and drop
+/// every one of them.
+fn expand(credit: &Credit, parts: &[String]) -> Vec<(String, Option<String>)> {
+    let names = cut(&credit.name);
+    let sorts = credit.sort_name.as_deref().map(cut).unwrap_or_default();
+    let paired: Vec<(String, Option<String>)> = if sorts.len() == names.len() {
+        names.into_iter().zip(sorts.into_iter().map(Some)).collect()
+    } else {
+        names.into_iter().map(|name| (name, None)).collect()
+    };
+    let mut by_name: HashMap<String, Option<String>> = HashMap::new();
+    for (name, sort) in paired {
+        by_name.entry(canonical(&name)).or_insert(sort);
+    }
+    parts
+        .iter()
+        .map(|part| {
+            let sort = by_name.get(&canonical(part)).cloned().flatten();
+            (part.clone(), sort)
+        })
+        .collect()
+}
+
+/// The participants one track credits: its first-step credits with the
+/// library's decisions applied.
+///
+/// `artist_override` is a correction someone typed (`track_override.artists`).
+/// It replaces the `artist` role whole and is final, so no decision touches
+/// it; every other role still follows the file and the decisions. A corrected
+/// name takes the album-artist sort form of the same name, as it did before
+/// this step existed.
+///
+/// `identity` is the artist id a name derives. A name whose artist already
+/// appears earlier in the same role and sub-role is not credited twice — the
+/// first occurrence wins — and positions are numbered from zero across each
+/// role, which `track_participant`'s `UNIQUE (track_id, role, position)` asks.
+pub fn resolve(
+    credits: &[Credit],
+    decisions: &Decisions,
+    artist_override: Option<&[String]>,
+    identity: impl Fn(&str) -> Uuid,
+) -> Vec<Credit> {
+    let mut ordered: Vec<&Credit> = credits.iter().collect();
+    // Role order first, then each role in its own order: the relation reads
+    // positions per role, and a stable order keeps two runs identical.
+    ordered.sort_by_key(|credit| (credit.role, credit.position));
+
+    let mut expanded: Vec<(Role, String, String, Option<String>)> = Vec::new();
+    if let Some(names) = artist_override {
+        for name in names {
+            let sort = credits
+                .iter()
+                .find(|credit| credit.role == Role::AlbumArtist && credit.name == *name)
+                .and_then(|credit| credit.sort_name.clone());
+            expanded.push((Role::Artist, String::new(), name.clone(), sort));
+        }
+    }
+    for credit in ordered {
+        if credit.role == Role::Artist && artist_override.is_some() {
+            continue;
+        }
+        match decisions.get(&credit_key(&credit.name)) {
+            Some(CreditDecision::Split(parts)) => {
+                for (name, sort) in expand(credit, parts) {
+                    expanded.push((credit.role, credit.sub_role.clone(), name, sort));
+                }
+            }
+            _ => expanded.push((
+                credit.role,
+                credit.sub_role.clone(),
+                credit.name.clone(),
+                credit.sort_name.clone(),
+            )),
+        }
+    }
+
+    let mut seen: HashSet<(Role, String, Uuid)> = HashSet::new();
+    let mut next: HashMap<Role, usize> = HashMap::new();
+    let mut resolved = Vec::with_capacity(expanded.len());
+    for (role, sub_role, name, sort_name) in expanded {
+        let name = name.trim().to_owned();
+        if name.is_empty() || !seen.insert((role, sub_role.clone(), identity(&name))) {
+            continue;
+        }
+        let position = next.entry(role).or_insert(0);
+        resolved.push(Credit {
+            role,
+            sub_role,
+            name,
+            sort_name,
+            position: *position,
+        });
+        *position += 1;
+    }
+    resolved
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn credit(role: Role, position: usize, name: &str, sort: Option<&str>) -> Credit {
+        Credit {
+            role,
+            sub_role: String::new(),
+            name: name.to_owned(),
+            sort_name: sort.map(str::to_owned),
+            position,
+        }
+    }
+
+    /// The identity the default spec derives, without a library: enough to
+    /// tell two names apart the way the catalogue does.
+    fn identity(name: &str) -> Uuid {
+        Uuid::new_v5(&Uuid::NAMESPACE_OID, credit_key(name).as_bytes())
+    }
+
+    fn names(credits: &[Credit], role: Role) -> Vec<(usize, &str)> {
+        credits
+            .iter()
+            .filter(|credit| credit.role == role)
+            .map(|credit| (credit.position, credit.name.as_str()))
+            .collect()
+    }
+
+    fn split(parts: &[&str]) -> CreditDecision {
+        CreditDecision::Split(parts.iter().map(|part| (*part).to_owned()).collect())
+    }
+
+    #[test]
+    fn the_fragments_are_the_desktops_with_parentheses_protected() {
+        assert_eq!(
+            fragments("Ashreveal, Ashish Swargiary"),
+            ["Ashreveal", "Ashish Swargiary"]
+        );
+        assert_eq!(fragments("蔡依林，周杰伦"), ["蔡依林", "周杰伦"]);
+        assert_eq!(fragments("庄心妍、祁隆"), ["庄心妍", "祁隆"]);
+        assert_eq!(fragments("A､B, C"), ["A", "B", "C"]);
+        assert_eq!(fragments("A, B, A"), ["A", "B"]);
+        assert_eq!(
+            fragments("Ian Asher, Olly Alexander (Years, Years)"),
+            ["Ian Asher", "Olly Alexander (Years, Years)"],
+            "a comma inside parentheses qualifies a name"
+        );
+    }
+
+    #[test]
+    fn a_candidate_has_two_fragments_and_none_is_the_whole() {
+        assert!(is_candidate("Zedd, Alessia Cara"));
+        assert!(is_candidate("Tyler, The Creator"), "only a person can tell");
+        assert!(!is_candidate("Solo,"));
+        assert!(!is_candidate("Simon & Garfunkel"));
+        assert!(!is_candidate("A, a"), "one fragment once deduplicated");
+    }
+
+    #[test]
+    fn the_key_folds_case_and_typographic_punctuation_only() {
+        assert_eq!(credit_key(" A, B "), credit_key("a, b"));
+        assert_eq!(credit_key("Guns N’ Roses"), credit_key("guns n' roses"));
+        assert_ne!(credit_key("AC/DC"), credit_key("AC DC"));
+    }
+
+    #[test]
+    fn a_split_replaces_the_credit_in_place_and_renumbers() {
+        let credits = [
+            credit(Role::Artist, 0, "X", None),
+            credit(Role::Artist, 1, "A, B", None),
+            credit(Role::Artist, 2, "Y", None),
+            credit(Role::AlbumArtist, 0, "A, B", None),
+        ];
+        let decisions = Decisions::from([(credit_key("A, B"), split(&["A", "B"]))]);
+        let resolved = resolve(&credits, &decisions, None, identity);
+        assert_eq!(
+            names(&resolved, Role::Artist),
+            [(0, "X"), (1, "A"), (2, "B"), (3, "Y")]
+        );
+        assert_eq!(names(&resolved, Role::AlbumArtist), [(0, "A"), (1, "B")]);
+    }
+
+    #[test]
+    fn no_decision_leaves_every_credit_as_the_file_wrote_it() {
+        let credits = [
+            credit(Role::Artist, 0, "A, B", Some("B, A")),
+            credit(Role::Composer, 0, "C, D", None),
+        ];
+        let resolved = resolve(&credits, &Decisions::new(), None, identity);
+        assert_eq!(resolved.len(), 2);
+        assert_eq!(resolved[0].sort_name.as_deref(), Some("B, A"));
+    }
+
+    #[test]
+    fn a_keep_changes_nothing() {
+        let credits = [credit(Role::Artist, 0, "Tyler, The Creator", None)];
+        let decisions = Decisions::from([(credit_key("Tyler, The Creator"), CreditDecision::Keep)]);
+        assert_eq!(
+            names(&resolve(&credits, &decisions, None, identity), Role::Artist),
+            [(0, "Tyler, The Creator")]
+        );
+    }
+
+    #[test]
+    fn a_part_already_credited_is_not_credited_twice() {
+        let credits = [
+            credit(Role::Artist, 0, "A", None),
+            credit(Role::Artist, 1, "a, B", None),
+        ];
+        let decisions = Decisions::from([(credit_key("a, B"), split(&["a", "B"]))]);
+        assert_eq!(
+            names(&resolve(&credits, &decisions, None, identity), Role::Artist),
+            [(0, "A"), (1, "B")],
+            "the first occurrence wins, and positions stay contiguous"
+        );
+    }
+
+    #[test]
+    fn two_credits_sharing_a_part_keep_the_files_order_whichever_is_undone() {
+        let credits = [
+            credit(Role::Artist, 0, "A, B", None),
+            credit(Role::Artist, 1, "A, C", None),
+        ];
+        let both = Decisions::from([
+            (credit_key("A, B"), split(&["A", "B"])),
+            (credit_key("A, C"), split(&["A", "C"])),
+        ]);
+        assert_eq!(
+            names(&resolve(&credits, &both, None, identity), Role::Artist),
+            [(0, "A"), (1, "B"), (2, "C")]
+        );
+        let first = Decisions::from([(credit_key("A, B"), split(&["A", "B"]))]);
+        assert_eq!(
+            names(&resolve(&credits, &first, None, identity), Role::Artist),
+            [(0, "A"), (1, "B"), (2, "A, C")]
+        );
+        let second = Decisions::from([(credit_key("A, C"), split(&["A", "C"]))]);
+        assert_eq!(
+            names(&resolve(&credits, &second, None, identity), Role::Artist),
+            [(0, "A, B"), (1, "A"), (2, "C")]
+        );
+    }
+
+    #[test]
+    fn sort_forms_are_paired_before_the_fragments_are_deduplicated() {
+        let credits = [credit(Role::Artist, 0, "A, B, B, C", Some("a, b, b, c"))];
+        let decisions = Decisions::from([(credit_key("A, B, B, C"), split(&["A", "B", "C"]))]);
+        let resolved = resolve(&credits, &decisions, None, identity);
+        let sorts: Vec<Option<&str>> = resolved
+            .iter()
+            .map(|credit| credit.sort_name.as_deref())
+            .collect();
+        assert_eq!(sorts, [Some("a"), Some("b"), Some("c")]);
+    }
+
+    #[test]
+    fn a_sort_form_of_another_length_pairs_with_nothing() {
+        let credits = [credit(Role::Artist, 0, "A, B", Some("a"))];
+        let decisions = Decisions::from([(credit_key("A, B"), split(&["A", "B"]))]);
+        assert!(resolve(&credits, &decisions, None, identity)
+            .iter()
+            .all(|credit| credit.sort_name.is_none()));
+    }
+
+    #[test]
+    fn a_retagged_spelling_falls_under_the_same_decision() {
+        let credits = [credit(Role::Artist, 0, "a, b", None)];
+        let decisions = Decisions::from([(credit_key("A, B"), split(&["A", "B"]))]);
+        assert_eq!(
+            names(&resolve(&credits, &decisions, None, identity), Role::Artist),
+            [(0, "A"), (1, "B")]
+        );
+    }
+
+    #[test]
+    fn a_correction_is_final_and_the_other_roles_still_follow_decisions() {
+        let credits = [
+            credit(Role::Artist, 0, "A, B", None),
+            credit(Role::AlbumArtist, 0, "A, B", Some("B, A")),
+        ];
+        let decisions = Decisions::from([(credit_key("A, B"), split(&["A", "B"]))]);
+        let corrected = ["A, B".to_owned()];
+        let resolved = resolve(&credits, &decisions, Some(&corrected), identity);
+        assert_eq!(names(&resolved, Role::Artist), [(0, "A, B")]);
+        assert_eq!(names(&resolved, Role::AlbumArtist), [(0, "A"), (1, "B")]);
+        assert_eq!(
+            resolved[0].sort_name.as_deref(),
+            Some("B, A"),
+            "a corrected name takes the album artist's sort form of that name"
+        );
+    }
+
+    #[test]
+    fn performers_number_one_sequence_across_their_instruments() {
+        let mut guitar = credit(Role::Performer, 0, "A, B", None);
+        guitar.sub_role = "Guitar".into();
+        let mut drums = credit(Role::Performer, 1, "C", None);
+        drums.sub_role = "Drums".into();
+        let decisions = Decisions::from([(credit_key("A, B"), split(&["A", "B"]))]);
+        let resolved = resolve(&[guitar, drums], &decisions, None, identity);
+        assert_eq!(
+            names(&resolved, Role::Performer),
+            [(0, "A"), (1, "B"), (2, "C")]
+        );
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 99b0b882..cae190fb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,6 +5,7 @@ pub mod authentication;
 pub mod catalog;
 pub mod cli;
 pub mod config;
+pub mod credit_split;
 pub mod database;
 pub mod enrichment;
 pub mod lyrics;
@@ -147,6 +148,12 @@ fn chunk_body_limit(limits: &config::UploadLimits) -> usize {
         api::delete_folder,
         api::folder_tracks,
         api::place_tracks,
+        api::attention_summary,
+        api::attention_credits,
+        api::attention_tracks,
+        api::list_credit_decisions,
+        api::create_credit_decision,
+        api::delete_credit_decision,
         api::get_track,
         api::update_track,
         api::get_track_lyrics,
@@ -317,6 +324,14 @@ fn chunk_body_limit(limits: &config::UploadLimits) -> usize {
         services::ArtistImageCandidate,
         api::DeezerPortraitPick,
         services::FiledTree,
+        services::AttentionCategory,
+        services::AttentionCount,
+        services::AttentionTrack,
+        services::CreditCandidate,
+        services::CreditFragment,
+        services::CreditDecisionKind,
+        services::CreditDecisionRecord,
+        api::CreditDecisionRequest,
         services::FolderPatch,
         services::FolderRemoved,
         services::Placed,
diff --git a/src/services/attention.rs b/src/services/attention.rs
new file mode 100644
index 00000000..14468d51
--- /dev/null
+++ b/src/services/attention.rs
@@ -0,0 +1,352 @@
+//! What a library's owners and managers are asked to look at (RFC-015
+//! decision 8): the joined credits waiting for a decision, and the desktop's
+//! track categories that the server can both compute and act on.
+//!
+//! Every track category reads the **effective** values — the file's tag
+//! unless `track_override` corrects it — so a track fixed in the editor leaves
+//! its category at once. Only available tracks count. A category offers no
+//! action of its own: it lists tracks, and the track editor is where they are
+//! fixed, as on the desktop.
+
+use std::collections::{BTreeMap, HashMap};
+
+use super::credit_decisions::curated_library;
+use super::*;
+
+/// One list on the page.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum AttentionCategory {
+    /// Joined credits with no decision (`GET …/attention/credits`).
+    SplitCredits,
+    MissingArtist,
+    MissingAlbum,
+    MissingYear,
+    MissingTrackNumber,
+    MissingCover,
+    AlbumYearConflict,
+    CompilationNoAlbumArtist,
+    DuplicateTrackNumber,
+    TrackNumberGap,
+    ProbableDuplicate,
+}
+
+impl AttentionCategory {
+    /// Display order, the desktop's.
+    pub const ALL: [Self; 11] = [
+        Self::SplitCredits,
+        Self::MissingArtist,
+        Self::MissingAlbum,
+        Self::MissingYear,
+        Self::MissingTrackNumber,
+        Self::MissingCover,
+        Self::AlbumYearConflict,
+        Self::CompilationNoAlbumArtist,
+        Self::DuplicateTrackNumber,
+        Self::TrackNumberGap,
+        Self::ProbableDuplicate,
+    ];
+
+    /// `None` for anything that is not a track category, so a route can answer
+    /// it as an invalid parameter.
+    pub fn parse_track_category(value: &str) -> Option<Self> {
+        let category: Self =
+            serde_json::from_value(serde_json::Value::String(value.into())).ok()?;
+        (category != Self::SplitCredits).then_some(category)
+    }
+}
+
+/// How many items one list holds.
+#[derive(Debug, Clone, Serialize, ToSchema)]
+pub struct AttentionCount {
+    pub category: AttentionCategory,
+    pub count: i64,
+}
+
+/// A track in one category. A probable duplicate carries the group it
+/// belongs to, numbered from one, so a client can draw the groups.
+#[derive(Debug, Clone, Serialize, ToSchema)]
+pub struct AttentionTrack {
+    #[serde(flatten)]
+    pub song: SongItem,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub duplicate_group: Option<i64>,
+}
+
+// The criteria, over `song_select!`'s aliases: `t` the track, `ovr` its
+// correction, `alb` its album. Static, as every query here is, and composed
+// with `concat!` so nothing is ever spliced in at run time.
+
+macro_rules! missing_artist {
+    () => {
+        "NOT EXISTS (SELECT 1 FROM track_participant tp \
+           WHERE tp.track_id = t.id AND tp.role = 'artist')"
+    };
+}
+macro_rules! missing_album {
+    () => {
+        "t.album_id IS NULL"
+    };
+}
+macro_rules! missing_year {
+    () => {
+        "COALESCE(ovr.year, t.year, 0) = 0"
+    };
+}
+macro_rules! missing_track_number {
+    () => {
+        "COALESCE(ovr.track_number, t.track_number, 0) <= 0"
+    };
+}
+// The album's cover stands for its tracks, as it does on every page that
+// draws one.
+macro_rules! missing_cover {
+    () => {
+        "t.artwork_hash IS NULL AND alb.artwork_hash IS NULL"
+    };
+}
+macro_rules! album_year_conflict {
+    () => {
+        "t.album_id IS NOT NULL AND (SELECT COUNT(DISTINCT COALESCE(o2.year, t2.year)) \
+           FROM track t2 LEFT JOIN track_override o2 ON o2.track_id = t2.id \
+           WHERE t2.album_id = t.album_id AND t2.is_available = 1 \
+             AND COALESCE(o2.year, t2.year, 0) > 0) > 1"
+    };
+}
+// The server files a compilation that names no album artist under `Various
+// Artists`, and cannot tell that fallback from a file that writes those words
+// itself — so both are listed; a compilation credited to nobody in particular
+// is the case either way.
+macro_rules! compilation_no_album_artist {
+    () => {
+        "alb.is_compilation = 1 AND alb.album_artist_name = 'Various Artists'"
+    };
+}
+macro_rules! duplicate_track_number {
+    () => {
+        "t.album_id IS NOT NULL AND COALESCE(ovr.track_number, t.track_number, 0) > 0 \
+         AND EXISTS (SELECT 1 FROM track t2 LEFT JOIN track_override o2 ON o2.track_id = t2.id \
+           WHERE t2.album_id = t.album_id AND t2.id <> t.id AND t2.is_available = 1 \
+             AND COALESCE(o2.disc_number, t2.disc_number, 1) \
+               = COALESCE(ovr.disc_number, t.disc_number, 1) \
+             AND COALESCE(o2.track_number, t2.track_number, 0) \
+               = COALESCE(ovr.track_number, t.track_number, 0))"
+    };
+}
+macro_rules! track_number_gap {
+    () => {
+        "t.album_id IS NOT NULL AND (SELECT \
+             MAX(COALESCE(o2.track_number, t2.track_number)) \
+           - MIN(COALESCE(o2.track_number, t2.track_number)) + 1 \
+           - COUNT(DISTINCT COALESCE(o2.track_number, t2.track_number)) \
+           FROM track t2 LEFT JOIN track_override o2 ON o2.track_id = t2.id \
+           WHERE t2.album_id = t.album_id AND t2.is_available = 1 \
+             AND COALESCE(o2.disc_number, t2.disc_number, 1) \
+               = COALESCE(ovr.disc_number, t.disc_number, 1) \
+             AND COALESCE(o2.track_number, t2.track_number, 0) > 0) > 0"
+    };
+}
+
+macro_rules! count_head {
+    () => {
+        "SELECT COUNT(*) FROM track t \
+         LEFT JOIN album alb ON alb.id = t.album_id \
+         LEFT JOIN track_override ovr ON ovr.track_id = t.id \
+         WHERE t.library_id = ? AND t.is_available = 1 AND ("
+    };
+}
+
+macro_rules! by_sleeve {
+    () => {
+        " ORDER BY t.album_title COLLATE NOCASE NULLS LAST, \
+           COALESCE(ovr.disc_number, t.disc_number) NULLS LAST, \
+           COALESCE(ovr.track_number, t.track_number) NULLS LAST, \
+           COALESCE(ovr.title, t.title) COLLATE NOCASE, t.id LIMIT ? OFFSET ?"
+    };
+}
+
+/// The count query and the listing query of one criterion.
+macro_rules! category_sql {
+    ($criterion:ident) => {
+        (
+            concat!(count_head!(), $criterion!(), ")"),
+            concat!(
+                song_select!(),
+                " AND t.library_id = ? AND (",
+                $criterion!(),
+                ")",
+                by_sleeve!()
+            ),
+        )
+    };
+}
+
+impl AttentionCategory {
+    /// Its two queries, for the categories SQL can answer alone.
+    fn sql(self) -> Option<(&'static str, &'static str)> {
+        Some(match self {
+            Self::MissingArtist => category_sql!(missing_artist),
+            Self::MissingAlbum => category_sql!(missing_album),
+            Self::MissingYear => category_sql!(missing_year),
+            Self::MissingTrackNumber => category_sql!(missing_track_number),
+            Self::MissingCover => category_sql!(missing_cover),
+            Self::AlbumYearConflict => category_sql!(album_year_conflict),
+            Self::CompilationNoAlbumArtist => category_sql!(compilation_no_album_artist),
+            Self::DuplicateTrackNumber => category_sql!(duplicate_track_number),
+            Self::TrackNumberGap => category_sql!(track_number_gap),
+            Self::SplitCredits | Self::ProbableDuplicate => return None,
+        })
+    }
+}
+
+impl DomainServices {
+    /// How many items each list holds, in display order.
+    pub async fn attention_summary(
+        &self,
+        user_id: Uuid,
+        library_id: Uuid,
+    ) -> Result<Vec<AttentionCount>, ServiceError> {
+        let candidates = self.credit_candidates(user_id, library_id).await?;
+        let duplicates = self.probable_duplicates(library_id).await?;
+        let mut counts = Vec::with_capacity(AttentionCategory::ALL.len());
+        for category in AttentionCategory::ALL {
+            let count = match category.sql() {
+                Some((count, _)) => {
+                    sqlx::query_scalar::<_, i64>(count)
+                        .bind(library_id.to_string())
+                        .fetch_one(self.db.pool())
+                        .await?
+                }
+                None if category == AttentionCategory::SplitCredits => candidates.len() as i64,
+                None => duplicates.len() as i64,
+            };
+            counts.push(AttentionCount { category, count });
+        }
+        Ok(counts)
+    }
+
+    /// One page of the tracks in one category.
+    pub async fn attention_tracks(
+        &self,
+        user_id: Uuid,
+        library_id: Uuid,
+        category: AttentionCategory,
+        page: BrowsePage,
+    ) -> Result<Vec<AttentionTrack>, ServiceError> {
+        {
+            let mut tx = self.db.pool().begin().await?;
+            curated_library(&mut tx, user_id, library_id).await?;
+            tx.commit().await?;
+        }
+        if let Some((_, listing)) = category.sql() {
+            let rows = sqlx::query(listing)
+                .bind(user_id.to_string())
+                .bind(library_id.to_string())
+                .bind(page.limit)
+                .bind(page.offset)
+                .fetch_all(self.db.pool())
+                .await?;
+            let mut songs = rows
+                .into_iter()
+                .map(song_from_row)
+                .collect::<Result<Vec<_>, _>>()?;
+            attach_song_relations(&mut *self.db.pool().acquire().await?, user_id, &mut songs)
+                .await?;
+            return Ok(songs
+                .into_iter()
+                .map(|song| AttentionTrack {
+                    song,
+                    duplicate_group: None,
+                })
+                .collect());
+        }
+        if category != AttentionCategory::ProbableDuplicate {
+            return Err(ServiceError::Invalid);
+        }
+        let all = self.probable_duplicates(library_id).await?;
+        let window: Vec<(Uuid, i64)> = all
+            .into_iter()
+            .skip(page.offset as usize)
+            .take(page.limit as usize)
+            .collect();
+        let ids: Vec<Uuid> = window.iter().map(|(id, _)| *id).collect();
+        let mut connection = self.db.pool().acquire().await?;
+        let songs = self
+            .songs_by_ids_lenient_on(&mut connection, user_id, &ids)
+            .await?;
+        let mut by_id: HashMap<Uuid, SongItem> =
+            songs.into_iter().map(|song| (song.id, song)).collect();
+        Ok(window
+            .into_iter()
+            .filter_map(|(id, group)| {
+                by_id.remove(&id).map(|song| AttentionTrack {
+                    song,
+                    duplicate_group: Some(group),
+                })
+            })
+            .collect())
+    }
+
+    /// Every available track of the library that is probably another one,
+    /// with its group: the same normalised title, the same credited artists,
+    /// and durations that chain within two seconds — the desktop's rule,
+    /// through the same two functions of `waveflow-core`.
+    ///
+    /// In a fixed order — groups by title and artists, members by duration —
+    /// so a page means the same thing on every request.
+    async fn probable_duplicates(
+        &self,
+        library_id: Uuid,
+    ) -> Result<Vec<(Uuid, i64)>, ServiceError> {
+        let tracks: Vec<(String, String, i64)> = sqlx::query_as(
+            "SELECT t.id, COALESCE(ovr.title, t.title), t.duration_ms FROM track t \
+             LEFT JOIN track_override ovr ON ovr.track_id = t.id \
+             WHERE t.library_id = ? AND t.is_available = 1",
+        )
+        .bind(library_id.to_string())
+        .fetch_all(self.db.pool())
+        .await?;
+        let credited: Vec<(String, String)> = sqlx::query_as(
+            "SELECT tp.track_id, tp.artist_id FROM track_participant tp \
+             JOIN track t ON t.id = tp.track_id \
+             WHERE t.library_id = ? AND t.is_available = 1 AND tp.role = 'artist'",
+        )
+        .bind(library_id.to_string())
+        .fetch_all(self.db.pool())
+        .await?;
+        let mut artists: HashMap<String, Vec<String>> = HashMap::new();
+        for (track, artist) in credited {
+            artists.entry(track).or_default().push(artist);
+        }
+        let mut buckets: BTreeMap<(String, String), Vec<(usize, i64)>> = BTreeMap::new();
+        for (index, (id, title, duration)) in tracks.iter().enumerate() {
+            let mut names = artists.remove(id).unwrap_or_default();
+            names.sort();
+            let key = (
+                waveflow_core::metadata::name_match::normalize_name(title),
+                names.join("|"),
+            );
+            buckets.entry(key).or_default().push((index, *duration));
+        }
+        let mut grouped = Vec::new();
+        let mut group = 0;
+        for items in buckets.into_values() {
+            let items: Vec<(i64, i64)> = items
+                .into_iter()
+                .map(|(index, duration)| (index as i64, duration))
+                .collect();
+            for members in waveflow_core::inventory::chain_by_duration(
+                &items,
+                waveflow_core::inventory::DURATION_TOLERANCE_MS,
+            ) {
+                group += 1;
+                for member in members {
+                    let id = Uuid::parse_str(&tracks[member as usize].0)
+                        .map_err(|_| ServiceError::Invalid)?;
+                    grouped.push((id, group));
+                }
+            }
+        }
+        Ok(grouped)
+    }
+}
diff --git a/src/services/credit_decisions.rs b/src/services/credit_decisions.rs
new file mode 100644
index 00000000..10e0c17e
--- /dev/null
+++ b/src/services/credit_decisions.rs
@@ -0,0 +1,751 @@
+//! Splitting a joined artist credit, by decision (RFC-015).
+//!
+//! A decision belongs to the library: taken by its owners and managers, read
+//! back by every scan, applied at once to the stored catalogue without
+//! reading a file, and undone the same way. The rule itself is
+//! `crate::credit_split`; this is who may invoke it, and what follows from it
+//! — the library feed, the derivations a scan would rerun, and the favourites
+//! and ratings that would otherwise point at an artist nobody credits.
+
+use std::collections::{BTreeSet, HashSet};
+
+use sqlx::{Sqlite, Transaction};
+use tokio::sync::OwnedMutexGuard;
+
+use super::*;
+use crate::authentication::now_ms;
+use crate::credit_split::{credit_key, fragments, is_candidate};
+use crate::database::LibraryRole;
+
+/// One fragment of a credit an owner is asked about, and whether the library
+/// already has an artist of that name — the strongest hint that a split is
+/// right.
+#[derive(Debug, Clone, Serialize, ToSchema)]
+pub struct CreditFragment {
+    pub name: String,
+    /// The artist this fragment would land on, when it exists already.
+    pub artist_id: Option<Uuid>,
+    /// Albums it is the album artist of, `0` when it does not exist.
+    pub album_count: i64,
+}
+
+/// A joined credit with no decision yet.
+#[derive(Debug, Clone, Serialize, ToSchema)]
+pub struct CreditCandidate {
+    /// The artist row the joined credit makes today.
+    pub artist_id: Uuid,
+    pub name: String,
+    /// Available tracks crediting it as artist or album artist.
+    pub track_count: i64,
+    pub fragments: Vec<CreditFragment>,
+}
+
+/// What was decided about a credit.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "lowercase")]
+pub enum CreditDecisionKind {
+    Split,
+    Keep,
+}
+
+impl CreditDecisionKind {
+    fn as_str(self) -> &'static str {
+        match self {
+            Self::Split => "split",
+            Self::Keep => "keep",
+        }
+    }
+}
+
+/// A recorded decision.
+#[derive(Debug, Clone, Serialize, ToSchema)]
+pub struct CreditDecisionRecord {
+    pub id: Uuid,
+    /// The credit as it read when the decision was taken.
+    pub credit: String,
+    pub decision: CreditDecisionKind,
+    /// The names a split credits instead, in order; absent for a keep.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub parts: Option<Vec<String>>,
+    /// Who decided, by username; `null` once that account is gone.
+    pub decided_by: Option<String>,
+    pub decided_at: i64,
+}
+
+/// The caller may decide about this library's credits: `NotFound` for a
+/// library they are not in, `Forbidden` for one they may only listen to, both
+/// answered as the same `404`.
+pub(super) async fn curated_library(
+    tx: &mut Transaction<'_, Sqlite>,
+    user_id: Uuid,
+    library_id: Uuid,
+) -> Result<(), ServiceError> {
+    let role: String =
+        sqlx::query_scalar("SELECT role FROM library_member WHERE user_id=? AND library_id=?")
+            .bind(user_id.to_string())
+            .bind(library_id.to_string())
+            .fetch_optional(&mut **tx)
+            .await?
+            .ok_or(ServiceError::NotFound)?;
+    let role = LibraryRole::from_str(&role).map_err(|_| ServiceError::Invalid)?;
+    if role.may_write_metadata() {
+        Ok(())
+    } else {
+        Err(ServiceError::Forbidden)
+    }
+}
+
+/// What a pass over the affected tracks changed, for the library feed.
+#[derive(Default)]
+struct Moved {
+    tracks: Vec<(Uuid, String)>,
+    albums: BTreeSet<Uuid>,
+}
+
+fn record_event(
+    library_id: Uuid,
+    entity_type: &'static str,
+    entity_id: Uuid,
+    action: &'static str,
+    payload: serde_json::Value,
+    now: i64,
+) -> crate::catalog::LibraryChange<'static> {
+    crate::catalog::LibraryChange {
+        library_id,
+        entity_type,
+        entity_id,
+        action,
+        payload,
+        changed_at: now,
+        origin_device_id: None,
+    }
+}
+
+impl DomainServices {
+    /// The joined credits of a library that wait for a decision (RFC-015
+    /// decision 8), sorted as the desktop sorts them: most fragments already
+    /// known first, then the most tracks, then the name.
+    pub async fn credit_candidates(
+        &self,
+        user_id: Uuid,
+        library_id: Uuid,
+    ) -> Result<Vec<CreditCandidate>, ServiceError> {
+        let mut tx = self.db.pool().begin().await?;
+        curated_library(&mut tx, user_id, library_id).await?;
+        // The four characters narrow the read; the rule itself is Rust's,
+        // because "two fragments, none the whole" is not a pattern.
+        let rows: Vec<(String, String, i64)> = sqlx::query_as(
+            "SELECT ar.id, ar.name, COUNT(DISTINCT t.id) FROM artist ar \
+             JOIN track_participant tp ON tp.artist_id = ar.id \
+               AND tp.role IN ('artist', 'albumartist') \
+             JOIN track t ON t.id = tp.track_id AND t.is_available = 1 \
+             WHERE ar.library_id = ? \
+               AND (ar.name LIKE '%,%' OR ar.name LIKE '%，%' \
+                    OR ar.name LIKE '%、%' OR ar.name LIKE '%､%') \
+             GROUP BY ar.id",
+        )
+        .bind(library_id.to_string())
+        .fetch_all(&mut *tx)
+        .await?;
+        let decided: HashSet<String> = sqlx::query_scalar(
+            "SELECT credit_key FROM artist_credit_decision WHERE library_id = ?",
+        )
+        .bind(library_id.to_string())
+        .fetch_all(&mut *tx)
+        .await?
+        .into_iter()
+        .collect();
+        let mut candidates = Vec::new();
+        for (id, name, track_count) in rows {
+            if !is_candidate(&name) || decided.contains(&credit_key(&name)) {
+                continue;
+            }
+            let mut parts = Vec::new();
+            for fragment in fragments(&name) {
+                let derived = self.db.pid().artist_id(library_id, fragment.trim());
+                let known: Option<i64> = sqlx::query_scalar(
+                    "SELECT COALESCE((SELECT album_count FROM artist_role_stats \
+                       WHERE artist_id = ar.id AND role = 'albumartist'), 0) \
+                     FROM artist ar WHERE ar.id = ? AND ar.library_id = ?",
+                )
+                .bind(derived.to_string())
+                .bind(library_id.to_string())
+                .fetch_optional(&mut *tx)
+                .await?;
+                parts.push(CreditFragment {
+                    name: fragment,
+                    artist_id: known.map(|_| derived),
+                    album_count: known.unwrap_or(0),
+                });
+            }
+            candidates.push(CreditCandidate {
+                artist_id: parse_uuid(id)?,
+                name,
+                track_count,
+                fragments: parts,
+            });
+        }
+        tx.commit().await?;
+        candidates.sort_by(|left, right| {
+            let known = |candidate: &CreditCandidate| {
+                candidate
+                    .fragments
+                    .iter()
+                    .filter(|fragment| fragment.artist_id.is_some())
+                    .count()
+            };
+            known(right)
+                .cmp(&known(left))
+                .then(right.track_count.cmp(&left.track_count))
+                .then_with(|| left.name.to_lowercase().cmp(&right.name.to_lowercase()))
+                .then_with(|| left.artist_id.cmp(&right.artist_id))
+        });
+        Ok(candidates)
+    }
+
+    /// A library's decisions, newest first.
+    pub async fn credit_decisions(
+        &self,
+        user_id: Uuid,
+        library_id: Uuid,
+    ) -> Result<Vec<CreditDecisionRecord>, ServiceError> {
+        let mut tx = self.db.pool().begin().await?;
+        curated_library(&mut tx, user_id, library_id).await?;
+        let rows = sqlx::query(
+            "SELECT d.id, d.credit, d.decision, d.parts, a.username, d.decided_at \
+             FROM artist_credit_decision d LEFT JOIN account a ON a.id = d.decided_by \
+             WHERE d.library_id = ? ORDER BY d.decided_at DESC, d.id",
+        )
+        .bind(library_id.to_string())
+        .fetch_all(&mut *tx)
+        .await?;
+        tx.commit().await?;
+        rows.into_iter().map(decision_from_row).collect()
+    }
+
+    /// Records a decision about the credit `artist_id` makes, and applies it at
+    /// once (RFC-015 decisions 3 and 5).
+    ///
+    /// The artist must be a candidate; a credit already decided is a `409`, so
+    /// changing one's mind is an undo followed by a new decision, and two
+    /// owners deciding at once cannot overwrite each other unseen.
+    pub async fn decide_credit(
+        &self,
+        user_id: Uuid,
+        library_id: Uuid,
+        artist_id: Uuid,
+        kind: CreditDecisionKind,
+    ) -> Result<CreditDecisionRecord, ServiceError> {
+        let writer = self.db.writer_guard().await;
+        let mut tx = self.db.pool().begin().await?;
+        curated_library(&mut tx, user_id, library_id).await?;
+        let name: String =
+            sqlx::query_scalar("SELECT name FROM artist WHERE id = ? AND library_id = ?")
+                .bind(artist_id.to_string())
+                .bind(library_id.to_string())
+                .fetch_optional(&mut *tx)
+                .await?
+                .ok_or(ServiceError::NotFound)?;
+        if !is_candidate(&name) {
+            return Err(ServiceError::Invalid);
+        }
+        let key = credit_key(&name);
+        let taken: Option<i64> = sqlx::query_scalar(
+            "SELECT 1 FROM artist_credit_decision WHERE library_id = ? AND credit_key = ?",
+        )
+        .bind(library_id.to_string())
+        .bind(&key)
+        .fetch_optional(&mut *tx)
+        .await?;
+        if taken.is_some() {
+            return Err(ServiceError::Conflict);
+        }
+        let parts = (kind == CreditDecisionKind::Split).then(|| fragments(&name));
+        let id = Uuid::new_v4();
+        let now = now_ms();
+        sqlx::query(
+            "INSERT INTO artist_credit_decision \
+               (id, library_id, credit_key, credit, decision, parts, decided_by, decided_at) \
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+        )
+        .bind(id.to_string())
+        .bind(library_id.to_string())
+        .bind(&key)
+        .bind(name.trim())
+        .bind(kind.as_str())
+        .bind(
+            parts
+                .as_ref()
+                .map(|parts| serde_json::to_string(parts).map_err(|_| ServiceError::Invalid))
+                .transpose()?,
+        )
+        .bind(user_id.to_string())
+        .bind(now)
+        .execute(&mut *tx)
+        .await?;
+
+        let mut receipts = Vec::new();
+        if let Some(parts) = &parts {
+            let tracks: Vec<String> = sqlx::query_scalar(
+                "SELECT DISTINCT track_id FROM track_participant WHERE artist_id = ?",
+            )
+            .bind(artist_id.to_string())
+            .fetch_all(&mut *tx)
+            .await?;
+            let moved = self
+                .recompute_tracks(&mut tx, library_id, &tracks, now)
+                .await?;
+            self.record_moved(&mut tx, library_id, &moved, now).await?;
+            let part_ids: Vec<Uuid> = parts
+                .iter()
+                .map(|part| self.db.pid().artist_id(library_id, part.trim()))
+                .collect();
+            for part in &part_ids {
+                crate::catalog::record_library_event(
+                    &mut tx,
+                    record_event(
+                        library_id,
+                        "artist",
+                        *part,
+                        "upsert",
+                        serde_json::json!({}),
+                        now,
+                    ),
+                )
+                .await?;
+            }
+            if !still_credited(&mut tx, artist_id).await? {
+                receipts = self
+                    .carry_user_data(&writer, &mut tx, artist_id, &part_ids)
+                    .await?;
+                crate::catalog::record_library_event(
+                    &mut tx,
+                    record_event(
+                        library_id,
+                        "artist",
+                        artist_id,
+                        "delete",
+                        serde_json::json!({}),
+                        now,
+                    ),
+                )
+                .await?;
+            }
+        }
+        tx.commit().await?;
+        drop(writer);
+        for (user, receipt) in receipts {
+            self.sync.publish(user, receipt);
+        }
+        if parts.is_some() {
+            self.rederive(library_id).await?;
+        }
+        self.credit_decisions(user_id, library_id)
+            .await?
+            .into_iter()
+            .find(|decision| decision.id == id)
+            .ok_or(ServiceError::NotFound)
+    }
+
+    /// Removes a decision and restores what the library would hold without it
+    /// (RFC-015 decision 7): the same computation, run again for the tracks
+    /// the split reached, reading the file's credits back from `track_credit`.
+    ///
+    /// Favourites carried onto the parts stay there: by now the account may
+    /// like them on their own merits.
+    pub async fn remove_credit_decision(
+        &self,
+        user_id: Uuid,
+        library_id: Uuid,
+        decision_id: Uuid,
+    ) -> Result<(), ServiceError> {
+        let writer = self.db.writer_guard().await;
+        let mut tx = self.db.pool().begin().await?;
+        curated_library(&mut tx, user_id, library_id).await?;
+        let row: (String, String, Option<String>) = sqlx::query_as(
+            "SELECT credit, decision, parts FROM artist_credit_decision \
+             WHERE id = ? AND library_id = ?",
+        )
+        .bind(decision_id.to_string())
+        .bind(library_id.to_string())
+        .fetch_optional(&mut *tx)
+        .await?
+        .ok_or(ServiceError::NotFound)?;
+        sqlx::query("DELETE FROM artist_credit_decision WHERE id = ?")
+            .bind(decision_id.to_string())
+            .execute(&mut *tx)
+            .await?;
+        let (credit, decision, parts) = row;
+        let split = decision == "split";
+        if split {
+            let parts: Vec<String> = parts
+                .and_then(|parts| serde_json::from_str(&parts).ok())
+                .unwrap_or_default();
+            let part_ids: Vec<Uuid> = parts
+                .iter()
+                .map(|part| self.db.pid().artist_id(library_id, part.trim()))
+                .collect();
+            // Every track the split reached credits at least one of its parts:
+            // the first occurrence of each is kept. Recomputing a track the
+            // undo does not change writes nothing, so a superset is safe.
+            let mut tracks = Vec::new();
+            for part in &part_ids {
+                tracks.extend(
+                    sqlx::query_scalar::<_, String>(
+                        "SELECT DISTINCT track_id FROM track_participant WHERE artist_id = ?",
+                    )
+                    .bind(part.to_string())
+                    .fetch_all(&mut *tx)
+                    .await?,
+                );
+            }
+            tracks.sort();
+            tracks.dedup();
+            let now = now_ms();
+            let moved = self
+                .recompute_tracks(&mut tx, library_id, &tracks, now)
+                .await?;
+            self.record_moved(&mut tx, library_id, &moved, now).await?;
+            let joined = self.db.pid().artist_id(library_id, credit.trim());
+            if still_credited(&mut tx, joined).await? {
+                crate::catalog::record_library_event(
+                    &mut tx,
+                    record_event(
+                        library_id,
+                        "artist",
+                        joined,
+                        "upsert",
+                        serde_json::json!({}),
+                        now,
+                    ),
+                )
+                .await?;
+            }
+            for part in &part_ids {
+                let action = if still_credited(&mut tx, *part).await? {
+                    "upsert"
+                } else {
+                    "delete"
+                };
+                crate::catalog::record_library_event(
+                    &mut tx,
+                    record_event(
+                        library_id,
+                        "artist",
+                        *part,
+                        action,
+                        serde_json::json!({}),
+                        now,
+                    ),
+                )
+                .await?;
+            }
+        }
+        tx.commit().await?;
+        drop(writer);
+        if split {
+            self.rederive(library_id).await?;
+        }
+        Ok(())
+    }
+
+    async fn recompute_tracks(
+        &self,
+        tx: &mut Transaction<'_, Sqlite>,
+        library_id: Uuid,
+        tracks: &[String],
+        now: i64,
+    ) -> Result<Moved, ServiceError> {
+        let decisions = crate::catalog::credit_decisions(tx, library_id).await?;
+        let mut moved = Moved::default();
+        for track in tracks {
+            let track_id = parse_uuid(track.clone())?;
+            let outcome = crate::catalog::recompute_track_participants(
+                tx,
+                self.db.pid(),
+                library_id,
+                track_id,
+                &decisions,
+                now,
+            )
+            .await?;
+            if outcome.changed {
+                moved.tracks.push((track_id, outcome.full_hash));
+                moved.albums.extend(outcome.album_id);
+            }
+        }
+        Ok(moved)
+    }
+
+    /// What a scan of the same change would put on the library feed: each
+    /// track with its hash, each album once.
+    async fn record_moved(
+        &self,
+        tx: &mut Transaction<'_, Sqlite>,
+        library_id: Uuid,
+        moved: &Moved,
+        now: i64,
+    ) -> Result<(), ServiceError> {
+        for (track, full_hash) in &moved.tracks {
+            crate::catalog::record_library_event(
+                tx,
+                record_event(
+                    library_id,
+                    "track",
+                    *track,
+                    "upsert",
+                    serde_json::json!({ "full_hash": full_hash }),
+                    now,
+                ),
+            )
+            .await?;
+        }
+        for album in &moved.albums {
+            crate::catalog::record_library_event(
+                tx,
+                record_event(
+                    library_id,
+                    "album",
+                    *album,
+                    "upsert",
+                    serde_json::json!({}),
+                    now,
+                ),
+            )
+            .await?;
+        }
+        Ok(())
+    }
+
+    /// The derivations a scan reruns at its end, rerun because the credits
+    /// they are derived from moved: album credits, per-role counts, the artist
+    /// sweep and the search index, then the sort names.
+    async fn rederive(&self, library_id: Uuid) -> Result<(), ServiceError> {
+        self.db.consolidate_catalog_derivations(library_id).await?;
+        self.db.consolidate_sort_names(library_id).await?;
+        Ok(())
+    }
+
+    /// Carries each account's favourite and rating on an artist the split
+    /// removed onto every part, through that account's journal (RFC-015
+    /// decision 4), so a desktop mirror sees the same move the server made.
+    ///
+    /// A part the account already starred keeps its own date; a part it
+    /// already rated keeps its own rating.
+    async fn carry_user_data(
+        &self,
+        writer: &OwnedMutexGuard<()>,
+        tx: &mut Transaction<'_, Sqlite>,
+        from: Uuid,
+        to: &[Uuid],
+    ) -> Result<Vec<(Uuid, MutationReceipt)>, ServiceError> {
+        let mut receipts = Vec::new();
+        let stars: Vec<(String, i64)> = sqlx::query_as(
+            "SELECT user_id, starred_at FROM user_star \
+             WHERE entity_type = 'artist' AND entity_id = ?",
+        )
+        .bind(from.to_string())
+        .fetch_all(&mut **tx)
+        .await?;
+        for (user, starred_at) in stars {
+            let user_id = parse_uuid(user)?;
+            for part in to {
+                let context = self.claim(writer, tx, user_id, "star", *part).await?;
+                sqlx::query(
+                    "INSERT INTO user_star (user_id, entity_type, entity_id, starred_at) \
+                     VALUES (?, 'artist', ?, ?) ON CONFLICT DO NOTHING",
+                )
+                .bind(user_id.to_string())
+                .bind(part.to_string())
+                .bind(starred_at)
+                .execute(&mut **tx)
+                .await?;
+                let receipt = self
+                    .sync
+                    .complete_operation(
+                        tx,
+                        user_id,
+                        context,
+                        "favorite",
+                        *part,
+                        "upsert",
+                        &serde_json::json!({
+                            "entity_type": "artist",
+                            "entity_id": part,
+                            "starred": true,
+                        }),
+                        Some(*part),
+                    )
+                    .await?;
+                receipts.push((user_id, receipt));
+            }
+            let context = self.claim(writer, tx, user_id, "unstar", from).await?;
+            sqlx::query(
+                "DELETE FROM user_star WHERE user_id = ? AND entity_type = 'artist' \
+                 AND entity_id = ?",
+            )
+            .bind(user_id.to_string())
+            .bind(from.to_string())
+            .execute(&mut **tx)
+            .await?;
+            let receipt = self
+                .sync
+                .complete_operation(
+                    tx,
+                    user_id,
+                    context,
+                    "favorite",
+                    from,
+                    "delete",
+                    &serde_json::json!({
+                        "entity_type": "artist",
+                        "entity_id": from,
+                        "starred": false,
+                    }),
+                    Some(from),
+                )
+                .await?;
+            receipts.push((user_id, receipt));
+        }
+
+        let ratings: Vec<(String, i64)> = sqlx::query_as(
+            "SELECT user_id, rating FROM user_rating \
+             WHERE entity_type = 'artist' AND entity_id = ?",
+        )
+        .bind(from.to_string())
+        .fetch_all(&mut **tx)
+        .await?;
+        for (user, rating) in ratings {
+            let user_id = parse_uuid(user)?;
+            for part in to {
+                let rated: Option<i64> = sqlx::query_scalar(
+                    "SELECT 1 FROM user_rating WHERE user_id = ? AND entity_type = 'artist' \
+                     AND entity_id = ?",
+                )
+                .bind(user_id.to_string())
+                .bind(part.to_string())
+                .fetch_optional(&mut **tx)
+                .await?;
+                if rated.is_some() {
+                    continue;
+                }
+                let context = self.claim(writer, tx, user_id, "set-rating", *part).await?;
+                sqlx::query(
+                    "INSERT INTO user_rating (user_id, entity_type, entity_id, rating, updated_at) \
+                     VALUES (?, 'artist', ?, ?, ?)",
+                )
+                .bind(user_id.to_string())
+                .bind(part.to_string())
+                .bind(rating)
+                .bind(now_ms())
+                .execute(&mut **tx)
+                .await?;
+                let receipt = self
+                    .sync
+                    .complete_operation(
+                        tx,
+                        user_id,
+                        context,
+                        "rating",
+                        *part,
+                        "upsert",
+                        &serde_json::json!({
+                            "entity_type": "artist",
+                            "entity_id": part,
+                            "rating": rating,
+                        }),
+                        Some(*part),
+                    )
+                    .await?;
+                receipts.push((user_id, receipt));
+            }
+            let context = self.claim(writer, tx, user_id, "set-rating", from).await?;
+            sqlx::query(
+                "DELETE FROM user_rating WHERE user_id = ? AND entity_type = 'artist' \
+                 AND entity_id = ?",
+            )
+            .bind(user_id.to_string())
+            .bind(from.to_string())
+            .execute(&mut **tx)
+            .await?;
+            let receipt = self
+                .sync
+                .complete_operation(
+                    tx,
+                    user_id,
+                    context,
+                    "rating",
+                    from,
+                    "delete",
+                    &serde_json::json!({
+                        "entity_type": "artist",
+                        "entity_id": from,
+                        "rating": 0,
+                    }),
+                    Some(from),
+                )
+                .await?;
+            receipts.push((user_id, receipt));
+        }
+        Ok(receipts)
+    }
+
+    /// Opens a journal operation the server makes on an account's behalf. A
+    /// fresh operation id cannot be a replay, so anything but a new claim is a
+    /// fault rather than an answer.
+    async fn claim(
+        &self,
+        writer: &OwnedMutexGuard<()>,
+        tx: &mut Transaction<'_, Sqlite>,
+        user_id: Uuid,
+        action: &str,
+        artist: Uuid,
+    ) -> Result<MutationContext, ServiceError> {
+        let context = MutationContext::server_generated();
+        let intent = MutationIntent::new(
+            action,
+            &format!("artist:{artist}"),
+            &serde_json::json!({ "credit_split": true }),
+        );
+        match self
+            .sync
+            .claim_operation(writer, tx, user_id, context, intent)
+            .await?
+        {
+            OperationClaim::New => Ok(context),
+            OperationClaim::Replayed(_) => Err(ServiceError::Conflict),
+        }
+    }
+}
+
+/// Whether anything still credits an artist: a participant, or an album that
+/// hangs off it. What the end-of-scan sweep checks before deleting the row.
+async fn still_credited(
+    tx: &mut Transaction<'_, Sqlite>,
+    artist_id: Uuid,
+) -> Result<bool, sqlx::Error> {
+    sqlx::query_scalar(
+        "SELECT EXISTS (SELECT 1 FROM track_participant WHERE artist_id = ?) \
+             OR EXISTS (SELECT 1 FROM album WHERE album_artist_id = ?)",
+    )
+    .bind(artist_id.to_string())
+    .bind(artist_id.to_string())
+    .fetch_one(&mut **tx)
+    .await
+}
+
+fn decision_from_row(row: sqlx::sqlite::SqliteRow) -> Result<CreditDecisionRecord, ServiceError> {
+    let decision = match row.try_get::<&str, _>("decision")? {
+        "split" => CreditDecisionKind::Split,
+        _ => CreditDecisionKind::Keep,
+    };
+    let parts: Option<String> = row.try_get("parts")?;
+    Ok(CreditDecisionRecord {
+        id: parse_uuid(row.try_get("id")?)?,
+        credit: row.try_get("credit")?,
+        decision,
+        parts: parts.and_then(|parts| serde_json::from_str(&parts).ok()),
+        decided_by: row.try_get("username")?,
+        decided_at: row.try_get("decided_at")?,
+    })
+}
diff --git a/src/services/mod.rs b/src/services/mod.rs
index a2d04184..642ceb9d 100644
--- a/src/services/mod.rs
+++ b/src/services/mod.rs
@@ -1410,10 +1410,12 @@ mod artist_image_search;
 mod artist_images;
 mod artists;
 mod artwork;
+mod attention;
 mod bookmarks;
 mod canvas;
 mod catalog;
 mod credentials;
+mod credit_decisions;
 mod favorites;
 mod lastfm;
 mod library_events;
@@ -1434,6 +1436,10 @@ pub(crate) mod uploads;
 
 pub use artist_image_search::{ArtistImageCandidate, ARTIST_IMAGE_SEARCH_DEADLINE};
 pub use artist_images::ArtistImageKind;
+pub use attention::{AttentionCategory, AttentionCount, AttentionTrack};
+pub use credit_decisions::{
+    CreditCandidate, CreditDecisionKind, CreditDecisionRecord, CreditFragment,
+};
 /// Crate-visible only: the adapter builds the browser-less journey's address
 /// from it, and nothing outside this binary has a use for it.
 pub(crate) use lastfm::LASTFM_AUTHORIZE_URL;
diff --git a/src/tags.rs b/src/tags.rs
index 7a242444..f2e94f2f 100644
--- a/src/tags.rs
+++ b/src/tags.rs
@@ -64,6 +64,12 @@ impl Role {
         }
     }
 
+    /// The role a stored name stands for, or `None` for one this vocabulary
+    /// does not hold.
+    pub fn parse(value: &str) -> Option<Self> {
+        Self::ALL.into_iter().find(|role| role.as_str() == value)
+    }
+
     /// The roles that name who the music is *by*, as opposed to who worked on
     /// it. These two are what `artists[]` and `albumArtists[]` render, and
     /// every other role is a contributor.
diff --git a/tests/credits.rs b/tests/credits.rs
new file mode 100644
index 00000000..e7566005
--- /dev/null
+++ b/tests/credits.rs
@@ -0,0 +1,1072 @@
+//! Splitting a joined artist credit, by decision, and "Needs attention"
+//! (RFC-015).
+//!
+//! The accounts here are rows written by hand and reach the routes through an
+//! API token, as in `tests/catalog.rs`: nothing in this target authenticates
+//! with a password, so nothing in it hands a literal to a hash.
+
+#[allow(dead_code)]
+mod support;
+
+use axum::body::Body;
+use axum::http::{Request, StatusCode};
+use serde_json::json;
+use support::*;
+use tower::ServiceExt;
+use uuid::Uuid;
+use waveflow_server::authentication::now_ms;
+use waveflow_server::catalog::CatalogTrackInput;
+use waveflow_server::database::{LibraryRole, LibraryVisibility};
+use waveflow_server::services::{
+    AttentionCategory, BrowsePage, CreditDecisionKind, TrackMetadataPatch,
+};
+use waveflow_server::AppState;
+
+/// One credited row: track, role, position, name, sort form.
+type Row = (String, String, i64, String, Option<String>);
+
+struct Shelf {
+    state: AppState,
+    config: waveflow_server::Config,
+    owner: Uuid,
+    library: Uuid,
+    scan: Uuid,
+    _temp: tempfile::TempDir,
+}
+
+async fn account(state: &AppState, name: &str) -> Uuid {
+    let id = Uuid::new_v4();
+    let now = now_ms();
+    sqlx::query(
+        "INSERT INTO account (id, username, password_hash, role, disabled, created_at, updated_at) \
+         VALUES (?, ?, 'this-account-never-authenticates', 'admin', 0, ?, ?)",
+    )
+    .bind(id.to_string())
+    .bind(name)
+    .bind(now)
+    .bind(now)
+    .execute(state.db.pool())
+    .await
+    .unwrap();
+    id
+}
+
+async fn shelf(name: &str) -> Shelf {
+    let (temp, config, state) = test_app().await;
+    let owner = account(&state, name).await;
+    let music = config.data_dir.join(name);
+    std::fs::create_dir_all(&music).unwrap();
+    let library = state
+        .db
+        .create_library(
+            owner,
+            name,
+            &std::fs::canonicalize(&music).unwrap(),
+            LibraryVisibility::Private,
+            now_ms(),
+        )
+        .await
+        .unwrap();
+    let scan = state
+        .db
+        .create_scan_job(library, Some(owner), "manual")
+        .await
+        .unwrap();
+    state.db.start_scan_job(scan, 1, false).await.unwrap();
+    Shelf {
+        state,
+        config,
+        owner,
+        library,
+        scan,
+        _temp: temp,
+    }
+}
+
+/// A file crediting `artist`, on its own album unless one is named, with no
+/// album-artist tag and no compilation flag: the album then hangs off the
+/// track's own credit, which is the case a split could have moved.
+fn file(index: usize, artist: &str, album: Option<&str>) -> CatalogTrackInput {
+    let mut input = catalog_input(index, artist);
+    input.title = format!("Track {index}");
+    input.album = album.map(str::to_owned);
+    input.is_compilation = false;
+    input.genre = None;
+    input
+}
+
+impl Shelf {
+    async fn apply(&self, input: &CatalogTrackInput) {
+        let existing: Option<String> =
+            sqlx::query_scalar("SELECT id FROM track WHERE library_id = ? AND relative_path = ?")
+                .bind(self.library.to_string())
+                .bind(&input.relative_path)
+                .fetch_optional(self.state.db.pool())
+                .await
+                .unwrap();
+        self.state
+            .db
+            .apply_catalog_track(
+                self.library,
+                self.scan,
+                input,
+                existing.map(|id| Uuid::parse_str(&id).unwrap()),
+                false,
+            )
+            .await
+            .unwrap();
+    }
+
+    async fn settle(&self) {
+        self.state
+            .db
+            .consolidate_catalog_derivations(self.library)
+            .await
+            .unwrap();
+        self.state
+            .db
+            .consolidate_sort_names(self.library)
+            .await
+            .unwrap();
+    }
+
+    async fn artist(&self, name: &str) -> Uuid {
+        let id: String =
+            sqlx::query_scalar("SELECT id FROM artist WHERE library_id = ? AND name = ?")
+                .bind(self.library.to_string())
+                .bind(name)
+                .fetch_one(self.state.db.pool())
+                .await
+                .unwrap_or_else(|_| panic!("no artist named {name:?}"));
+        Uuid::parse_str(&id).unwrap()
+    }
+
+    async fn artist_names(&self) -> Vec<String> {
+        sqlx::query_scalar("SELECT name FROM artist WHERE library_id = ? ORDER BY name")
+            .bind(self.library.to_string())
+            .fetch_all(self.state.db.pool())
+            .await
+            .unwrap()
+    }
+
+    async fn split(&self, name: &str) -> Uuid {
+        let artist = self.artist(name).await;
+        self.state
+            .services
+            .decide_credit(self.owner, self.library, artist, CreditDecisionKind::Split)
+            .await
+            .unwrap()
+            .id
+    }
+
+    async fn undo(&self, decision: Uuid) {
+        self.state
+            .services
+            .remove_credit_decision(self.owner, self.library, decision)
+            .await
+            .unwrap();
+    }
+
+    /// Every credited row of the library, by file, role and position.
+    async fn rows(&self) -> Vec<Row> {
+        sqlx::query_as(
+            "SELECT t.relative_path, tp.role, tp.position, ar.name, tp.sort_name \
+             FROM track_participant tp JOIN track t ON t.id = tp.track_id \
+             JOIN artist ar ON ar.id = tp.artist_id \
+             WHERE t.library_id = ? ORDER BY t.relative_path, tp.role, tp.position",
+        )
+        .bind(self.library.to_string())
+        .fetch_all(self.state.db.pool())
+        .await
+        .unwrap()
+    }
+
+    /// One file's names in one role, in order.
+    async fn credited(&self, index: usize, role: &str) -> Vec<String> {
+        sqlx::query_scalar(
+            "SELECT ar.name FROM track_participant tp JOIN track t ON t.id = tp.track_id \
+             JOIN artist ar ON ar.id = tp.artist_id \
+             WHERE t.library_id = ? AND t.relative_path = ? AND tp.role = ? \
+             ORDER BY tp.position",
+        )
+        .bind(self.library.to_string())
+        .bind(format!("track-{index}.flac"))
+        .bind(role)
+        .fetch_all(self.state.db.pool())
+        .await
+        .unwrap()
+    }
+
+    async fn token(&self, user: Uuid, name: &str) -> String {
+        self.state
+            .services
+            .create_api_token(user, &[], name, "credit decisions", &[])
+            .await
+            .unwrap()
+            .1
+    }
+}
+
+fn names(values: &[&str]) -> Vec<String> {
+    values.iter().map(|value| (*value).to_owned()).collect()
+}
+
+#[tokio::test]
+async fn a_split_lands_on_the_artists_the_parts_name() {
+    let shelf = shelf("split-lands").await;
+    shelf
+        .apply(&file(0, "Ashreveal, Ashish Swargiary", Some("Duo")))
+        .await;
+    shelf.apply(&file(1, "Ashreveal", Some("Solo"))).await;
+    shelf.settle().await;
+    let solo = shelf.artist("Ashreveal").await;
+
+    shelf.split("Ashreveal, Ashish Swargiary").await;
+
+    assert_eq!(
+        shelf.credited(0, "artist").await,
+        names(&["Ashreveal", "Ashish Swargiary"])
+    );
+    assert_eq!(
+        shelf.artist("Ashreveal").await,
+        solo,
+        "the split credit lands on the artist the solo tracks already name"
+    );
+    assert_eq!(
+        shelf.artist_names().await,
+        names(&["Ashish Swargiary", "Ashreveal"]),
+        "the joined artist is swept once nothing credits it"
+    );
+}
+
+#[tokio::test]
+async fn an_album_keeps_its_id_through_a_split() {
+    let shelf = shelf("album-keeps").await;
+    shelf
+        .apply(&file(0, "Zedd, Alessia Cara", Some("Stay")))
+        .await;
+    shelf.settle().await;
+    let before: (String, String) =
+        sqlx::query_as("SELECT id, album_artist_name FROM album WHERE library_id = ?")
+            .bind(shelf.library.to_string())
+            .fetch_one(shelf.state.db.pool())
+            .await
+            .unwrap();
+
+    shelf.split("Zedd, Alessia Cara").await;
+    // Right after the decision, and again after the scan that reads the file
+    // afterwards: the decision's own pass and the scan each write the album.
+    for moment in ["after the decision", "after a rescan"] {
+        if moment == "after a rescan" {
+            shelf
+                .apply(&file(0, "Zedd, Alessia Cara", Some("Stay")))
+                .await;
+            shelf.settle().await;
+        }
+        let after: Vec<(String, String, String)> = sqlx::query_as(
+            "SELECT id, album_artist_name, album_artist_id FROM album WHERE library_id = ?",
+        )
+        .bind(shelf.library.to_string())
+        .fetch_all(shelf.state.db.pool())
+        .await
+        .unwrap();
+        assert_eq!(
+            after.len(),
+            1,
+            "{moment}: one album, not a second one minted beside it"
+        );
+        assert_eq!(
+            (after[0].0.clone(), after[0].1.clone()),
+            before,
+            "{moment}: the album's id and display stay what the file said"
+        );
+        assert_eq!(
+            after[0].2,
+            shelf.artist("Zedd").await.to_string(),
+            "{moment}: the album hangs off the first part"
+        );
+        assert_eq!(
+            shelf.credited(0, "albumartist").await,
+            names(&["Zedd", "Alessia Cara"]),
+            "{moment}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn a_scan_applies_a_decision_to_every_file_it_reads() {
+    let shelf = shelf("scan-applies").await;
+    shelf
+        .apply(&file(0, "Ice Spice, Central Cee", Some("Did It First")))
+        .await;
+    shelf.settle().await;
+    shelf.split("Ice Spice, Central Cee").await;
+
+    // A file the scan reads for the first time, and one it reads again
+    // because it changed: both come back split, which the desktop's own
+    // split never survived.
+    shelf
+        .apply(&file(1, "Ice Spice, Central Cee", Some("Single")))
+        .await;
+    let mut changed = file(0, "Ice Spice, Central Cee", Some("Did It First"));
+    changed.modified_at += 1;
+    changed.title = "Did It First (retagged)".into();
+    shelf.apply(&changed).await;
+    shelf.settle().await;
+
+    for index in [0, 1] {
+        assert_eq!(
+            shelf.credited(index, "artist").await,
+            names(&["Ice Spice", "Central Cee"]),
+            "file {index}"
+        );
+    }
+    assert!(
+        !shelf
+            .artist_names()
+            .await
+            .contains(&"Ice Spice, Central Cee".to_owned()),
+        "no scan brings the joined artist back"
+    );
+}
+
+#[tokio::test]
+async fn an_undo_restores_what_a_scan_without_the_decision_writes() {
+    let shelf = shelf("undo-restores").await;
+    let mut lead = file(0, "X, Y", Some("Pair"));
+    lead.sort_artist = Some("Xsort, Ysort".into());
+    shelf.apply(&lead).await;
+    shelf.apply(&file(1, "Z feat. X, Y", Some("Guest"))).await;
+    shelf.settle().await;
+    let whole = shelf.rows().await;
+
+    let decision = shelf.split("X, Y").await;
+    let split = shelf.rows().await;
+    assert_ne!(split, whole);
+    // A rescan of the same files writes exactly what the decision wrote.
+    shelf.apply(&lead).await;
+    shelf.apply(&file(1, "Z feat. X, Y", Some("Guest"))).await;
+    shelf.settle().await;
+    assert_eq!(shelf.rows().await, split, "a split and a rescan agree");
+
+    shelf.undo(decision).await;
+    assert_eq!(shelf.rows().await, whole, "the undo is a scan without it");
+    assert!(shelf.artist_names().await.contains(&"X, Y".to_owned()));
+    assert!(shelf
+        .state
+        .services
+        .credit_decisions(shelf.owner, shelf.library)
+        .await
+        .unwrap()
+        .is_empty());
+}
+
+#[tokio::test]
+async fn two_credits_sharing_a_part_keep_the_files_order_whichever_is_undone() {
+    let shelf = shelf("shared-part").await;
+    let mut both = file(0, "ignored", Some("Shared"));
+    // The plural tag is never cut by the first step, so each value is one
+    // credit and the two share their first fragment. Out of alphabetical
+    // order on purpose, at every level: an order taken from the names rather
+    // than from the file would put every list below the other way round.
+    both.artists = names(&["Z, Y", "Z, X"]);
+    shelf.apply(&both).await;
+    shelf.settle().await;
+
+    let first = shelf.split("Z, Y").await;
+    let second = shelf.split("Z, X").await;
+    assert_eq!(shelf.credited(0, "artist").await, names(&["Z", "Y", "X"]));
+
+    shelf.undo(second).await;
+    assert_eq!(
+        shelf.credited(0, "artist").await,
+        names(&["Z", "Y", "Z, X"])
+    );
+
+    let second = shelf.split("Z, X").await;
+    shelf.undo(first).await;
+    assert_eq!(
+        shelf.credited(0, "artist").await,
+        names(&["Z, Y", "Z", "X"]),
+        "the order is the file's, not what the shared part became"
+    );
+    shelf.undo(second).await;
+    assert_eq!(shelf.credited(0, "artist").await, names(&["Z, Y", "Z, X"]));
+}
+
+#[tokio::test]
+async fn a_correction_survives_a_split_and_a_rescan() {
+    let shelf = shelf("correction-final").await;
+    let mut input = file(0, "Hanumankind, Kalmi", Some("Big Dawgs"));
+    input.album_artist = Some("Hanumankind, Kalmi".into());
+    shelf.apply(&input).await;
+    shelf.settle().await;
+    let track: String = sqlx::query_scalar("SELECT id FROM track WHERE library_id = ?")
+        .bind(shelf.library.to_string())
+        .fetch_one(shelf.state.db.pool())
+        .await
+        .unwrap();
+    shelf
+        .state
+        .services
+        .set_track_metadata(
+            shelf.owner,
+            Uuid::parse_str(&track).unwrap(),
+            TrackMetadataPatch {
+                artists: Some(Some(names(&["Hanumankind, Kalmi"]))),
+                ..TrackMetadataPatch::default()
+            },
+            None,
+        )
+        .await
+        .unwrap();
+
+    shelf.split("Hanumankind, Kalmi").await;
+    // Right after the decision, whose own pass rewrites the track, and after
+    // the scan that reads the file again: each could undo the correction.
+    for moment in ["after the decision", "after a rescan"] {
+        if moment == "after a rescan" {
+            shelf.apply(&input).await;
+            shelf.settle().await;
+        }
+        assert_eq!(
+            shelf.credited(0, "artist").await,
+            names(&["Hanumankind, Kalmi"]),
+            "{moment}: a list someone typed is final"
+        );
+        assert_eq!(
+            shelf.credited(0, "albumartist").await,
+            names(&["Hanumankind", "Kalmi"]),
+            "{moment}: the roles the correction does not cover still follow the decision"
+        );
+    }
+}
+
+#[tokio::test]
+async fn a_split_keeps_each_parts_sort_form() {
+    let shelf = shelf("sort-forms").await;
+    let mut input = file(0, "A, B, B, C", Some("Sorted"));
+    input.sort_artist = Some("a, b, b, c".into());
+    shelf.apply(&input).await;
+    shelf.settle().await;
+
+    shelf.split("A, B, B, C").await;
+
+    let sorts: Vec<(String, Option<String>)> = sqlx::query_as(
+        "SELECT ar.name, tp.sort_name FROM track_participant tp \
+         JOIN artist ar ON ar.id = tp.artist_id \
+         WHERE tp.library_id = ? AND tp.role = 'artist' ORDER BY tp.position",
+    )
+    .bind(shelf.library.to_string())
+    .fetch_all(shelf.state.db.pool())
+    .await
+    .unwrap();
+    assert_eq!(
+        sorts,
+        vec![
+            ("A".to_owned(), Some("a".to_owned())),
+            ("B".to_owned(), Some("b".to_owned())),
+            ("C".to_owned(), Some("c".to_owned())),
+        ]
+    );
+}
+
+#[tokio::test]
+async fn a_retagged_spelling_is_still_split_and_still_undone() {
+    let shelf = shelf("retagged").await;
+    shelf
+        .apply(&file(0, "Drake, Lil Durk", Some("Laugh Now")))
+        .await;
+    shelf.settle().await;
+    let decision = shelf.split("Drake, Lil Durk").await;
+
+    let mut retagged = file(0, "drake, lil durk", Some("Laugh Now"));
+    retagged.modified_at += 1;
+    shelf.apply(&retagged).await;
+    shelf.settle().await;
+    assert_eq!(
+        shelf.credited(0, "artist").await,
+        names(&["Drake", "Lil Durk"]),
+        "the key folds case, so the new spelling is the same credit"
+    );
+
+    shelf.undo(decision).await;
+    assert_eq!(
+        shelf.credited(0, "artist").await,
+        names(&["drake, lil durk"]),
+        "the undo restores this file's own spelling"
+    );
+}
+
+#[tokio::test]
+async fn favourites_and_ratings_follow_the_parts_through_the_journal() {
+    let shelf = shelf("favourites-follow").await;
+    shelf
+        .apply(&file(0, "Tame Impala, JENNIE", Some("Dracula")))
+        .await;
+    shelf.apply(&file(1, "JENNIE", Some("Ruby"))).await;
+    shelf.settle().await;
+    let joined = shelf.artist("Tame Impala, JENNIE").await;
+    let jennie = shelf.artist("JENNIE").await;
+    let services = &shelf.state.services;
+    services
+        .set_star(shelf.owner, "artist", joined, true)
+        .await
+        .unwrap();
+    services
+        .set_rating(shelf.owner, "artist", joined, 4)
+        .await
+        .unwrap();
+    services
+        .set_rating(shelf.owner, "artist", jennie, 2)
+        .await
+        .unwrap();
+
+    shelf.split("Tame Impala, JENNIE").await;
+    let tame = shelf.artist("Tame Impala").await;
+
+    let starred: Vec<String> = sqlx::query_scalar(
+        "SELECT entity_id FROM user_star WHERE user_id = ? AND entity_type = 'artist' \
+         ORDER BY entity_id",
+    )
+    .bind(shelf.owner.to_string())
+    .fetch_all(shelf.state.db.pool())
+    .await
+    .unwrap();
+    let mut expected = vec![tame.to_string(), jennie.to_string()];
+    expected.sort();
+    assert_eq!(starred, expected, "the favourite is on every part");
+
+    let rated: Vec<(String, i64)> = sqlx::query_as(
+        "SELECT entity_id, rating FROM user_rating WHERE user_id = ? AND entity_type = 'artist' \
+         ORDER BY entity_id",
+    )
+    .bind(shelf.owner.to_string())
+    .fetch_all(shelf.state.db.pool())
+    .await
+    .unwrap();
+    let mut expected = vec![(tame.to_string(), 4), (jennie.to_string(), 2)];
+    expected.sort();
+    assert_eq!(rated, expected, "a part rated on its own keeps its rating");
+
+    // The journal says what moved, so a mirror converges on the same state.
+    let journal: Vec<(String, String, String)> = sqlx::query_as(
+        "SELECT entity_type, entity_id, action FROM sync_event WHERE user_id = ? \
+         AND entity_id IN (?, ?, ?) ORDER BY cursor",
+    )
+    .bind(shelf.owner.to_string())
+    .bind(joined.to_string())
+    .bind(tame.to_string())
+    .bind(jennie.to_string())
+    .fetch_all(shelf.state.db.pool())
+    .await
+    .unwrap();
+    for entry in [
+        ("favorite", joined, "delete"),
+        ("favorite", tame, "upsert"),
+        ("favorite", jennie, "upsert"),
+        ("rating", joined, "delete"),
+        ("rating", tame, "upsert"),
+    ] {
+        let entry = (entry.0.to_owned(), entry.1.to_string(), entry.2.to_owned());
+        assert!(
+            journal.contains(&entry),
+            "{entry:?} missing from {journal:?}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn the_feed_announces_what_a_split_moved() {
+    let shelf = shelf("feed").await;
+    shelf.apply(&file(0, "Curio, Lucy", Some("Echoes"))).await;
+    shelf.settle().await;
+    let joined = shelf.artist("Curio, Lucy").await;
+    let cursor: i64 = sqlx::query_scalar("SELECT COALESCE(MAX(cursor), 0) FROM library_event")
+        .fetch_one(shelf.state.db.pool())
+        .await
+        .unwrap();
+
+    shelf.split("Curio, Lucy").await;
+
+    let events: Vec<(String, String, String)> = sqlx::query_as(
+        "SELECT entity_type, entity_id, action FROM library_event \
+         WHERE library_id = ? AND cursor > ? ORDER BY cursor",
+    )
+    .bind(shelf.library.to_string())
+    .bind(cursor)
+    .fetch_all(shelf.state.db.pool())
+    .await
+    .unwrap();
+    let kinds: Vec<(&str, &str)> = events
+        .iter()
+        .map(|(kind, _, action)| (kind.as_str(), action.as_str()))
+        .collect();
+    assert!(kinds.contains(&("track", "upsert")), "{events:?}");
+    assert!(kinds.contains(&("album", "upsert")), "{events:?}");
+    assert!(
+        events.contains(&("artist".into(), joined.to_string(), "delete".into())),
+        "{events:?}"
+    );
+}
+
+/// The migration fills `track_credit` from the participants. Rebuilding it
+/// that way on a scanned library must answer what the scan's own credits
+/// answer, under no decision, a split and its undo — including a file that
+/// repeats a credit and one whose credits share a part.
+#[tokio::test]
+async fn the_migrations_copy_gives_what_a_scan_gives() {
+    let migration = include_str!("../migrations-v2/20261024020000_artist_credit_decision.sql");
+    let copy = &migration[migration
+        .find("INSERT INTO track_credit")
+        .expect("the migration copies the participants")..];
+
+    let inputs = || {
+        let mut repeated = file(0, "ignored", Some("Twice"));
+        repeated.artists = names(&["A, C", "A, C"]);
+        let mut shared = file(1, "ignored", Some("Shared"));
+        shared.artists = names(&["A, B", "A, C"]);
+        let mut sorted = file(2, "A, B", Some("Sorted"));
+        sorted.sort_artist = Some("a, b".into());
+        [repeated, shared, sorted]
+    };
+    let mut answers = Vec::new();
+    for copied in [false, true] {
+        let shelf = shelf(if copied { "copied" } else { "scanned" }).await;
+        for input in inputs() {
+            shelf.apply(&input).await;
+        }
+        shelf.settle().await;
+        if copied {
+            sqlx::query("DELETE FROM track_credit")
+                .execute(shelf.state.db.pool())
+                .await
+                .unwrap();
+            sqlx::raw_sql(copy)
+                .execute(shelf.state.db.pool())
+                .await
+                .unwrap();
+        }
+        let whole = shelf.rows().await;
+        let first = shelf.split("A, B").await;
+        let second = shelf.split("A, C").await;
+        let split = shelf.rows().await;
+        shelf.undo(first).await;
+        let half = shelf.rows().await;
+        shelf.undo(second).await;
+        let undone = shelf.rows().await;
+        assert_eq!(undone, whole, "copied: {copied}");
+        answers.push((whole, split, half));
+    }
+    assert_eq!(answers[0], answers[1]);
+}
+
+#[tokio::test]
+async fn the_candidates_are_the_desktops_sorted_as_the_desktop_sorts_them() {
+    let shelf = shelf("candidates").await;
+    shelf
+        .apply(&file(0, "Megan Thee Stallion, TWICE", Some("Mamushi")))
+        .await;
+    shelf.apply(&file(1, "TWICE", Some("Fancy"))).await;
+    shelf
+        .apply(&file(2, "Didier Super, The Aro String Band", Some("A")))
+        .await;
+    shelf
+        .apply(&file(3, "Didier Super, The Aro String Band", Some("B")))
+        .await;
+    shelf
+        .apply(&file(4, "Tyler, The Creator", Some("Igor")))
+        .await;
+    shelf
+        .apply(&file(5, "Simon & Garfunkel", Some("Bookends")))
+        .await;
+    shelf
+        .apply(&file(
+            6,
+            "Ian Asher, Olly Alexander (Years, Years)",
+            Some("Sun"),
+        ))
+        .await;
+    shelf.apply(&file(7, "Solo,", Some("Alone"))).await;
+    shelf.settle().await;
+
+    let candidates = shelf
+        .state
+        .services
+        .credit_candidates(shelf.owner, shelf.library)
+        .await
+        .unwrap();
+    let listed: Vec<&str> = candidates.iter().map(|c| c.name.as_str()).collect();
+    assert_eq!(
+        listed,
+        [
+            "Megan Thee Stallion, TWICE",
+            "Didier Super, The Aro String Band",
+            "Ian Asher, Olly Alexander (Years, Years)",
+            "Tyler, The Creator",
+        ],
+        "a known fragment first, then the most tracks, then the name"
+    );
+    let megan = &candidates[0];
+    assert_eq!(megan.track_count, 1);
+    assert_eq!(megan.fragments[1].name, "TWICE");
+    assert_eq!(
+        megan.fragments[1].artist_id,
+        Some(shelf.artist("TWICE").await)
+    );
+    assert_eq!(megan.fragments[0].artist_id, None);
+
+    let tyler = shelf.artist("Tyler, The Creator").await;
+    shelf
+        .state
+        .services
+        .decide_credit(shelf.owner, shelf.library, tyler, CreditDecisionKind::Keep)
+        .await
+        .unwrap();
+    assert!(
+        shelf
+            .state
+            .services
+            .credit_candidates(shelf.owner, shelf.library)
+            .await
+            .unwrap()
+            .iter()
+            .all(|candidate| candidate.name != "Tyler, The Creator"),
+        "a keep takes the credit off the list"
+    );
+    assert_eq!(
+        shelf.credited(4, "artist").await,
+        names(&["Tyler, The Creator"]),
+        "and changes nothing it credits"
+    );
+}
+
+#[tokio::test]
+async fn only_owners_and_managers_reach_the_page_and_its_decisions() {
+    let shelf = shelf("page-access").await;
+    shelf
+        .apply(&file(0, "Chris Lake, Abel Balder", Some("A")))
+        .await;
+    shelf.apply(&file(1, "Plain", Some("B"))).await;
+    shelf.settle().await;
+    let listener = account(&shelf.state, "listener").await;
+    let manager = account(&shelf.state, "manager").await;
+    for (user, role) in [
+        (listener, LibraryRole::Listener),
+        (manager, LibraryRole::Manager),
+    ] {
+        shelf
+            .state
+            .db
+            .add_library_member(shelf.owner, shelf.library, user, role, now_ms())
+            .await
+            .unwrap();
+    }
+    let router = waveflow_server::app(&shelf.config, shelf.state.clone());
+    let library = shelf.library;
+    let send = |token: String, request: Request<Body>| {
+        let router = router.clone();
+        async move {
+            let (mut parts, body) = request.into_parts();
+            parts
+                .headers
+                .insert("authorization", format!("Bearer {token}").parse().unwrap());
+            router
+                .oneshot(Request::from_parts(parts, body))
+                .await
+                .unwrap()
+        }
+    };
+    let listening = shelf.token(listener, "listener").await;
+    let managing = shelf.token(manager, "manager").await;
+    let joined = shelf.artist("Chris Lake, Abel Balder").await;
+    let plain = shelf.artist("Plain").await;
+    let get = |path: &str| {
+        Request::get(format!("/api/v2/libraries/{library}{path}"))
+            .body(Body::empty())
+            .unwrap()
+    };
+    let decide = |artist: Uuid| {
+        json_request(
+            &format!("/api/v2/libraries/{library}/credit-decisions"),
+            json!({ "artist_id": artist, "decision": "split" }),
+        )
+    };
+
+    for path in [
+        "/attention",
+        "/attention/credits",
+        "/attention/tracks?category=missing_year",
+        "/credit-decisions",
+    ] {
+        assert_eq!(
+            send(listening.clone(), get(path)).await.status(),
+            StatusCode::NOT_FOUND,
+            "a listener is told nothing at {path}"
+        );
+        assert_eq!(
+            send(managing.clone(), get(path)).await.status(),
+            StatusCode::OK,
+            "a manager reads {path}"
+        );
+    }
+    assert_eq!(
+        send(listening.clone(), decide(joined)).await.status(),
+        StatusCode::NOT_FOUND
+    );
+    assert_eq!(
+        send(
+            managing.clone(),
+            get("/attention/tracks?category=split_credits")
+        )
+        .await
+        .status(),
+        StatusCode::UNPROCESSABLE_ENTITY,
+        "credits are not a track category"
+    );
+    assert_eq!(
+        send(managing.clone(), decide(plain)).await.status(),
+        StatusCode::UNPROCESSABLE_ENTITY,
+        "a name with nothing to split is not a candidate"
+    );
+
+    let created = send(managing.clone(), decide(joined)).await;
+    assert_eq!(created.status(), StatusCode::CREATED);
+    let created = json_body(created).await;
+    assert_eq!(created["decision"], "split");
+    assert_eq!(created["parts"], json!(["Chris Lake", "Abel Balder"]));
+    assert_eq!(created["decided_by"], "manager");
+
+    // Decided, the joined artist is gone: deciding again names nothing.
+    assert_eq!(
+        send(managing.clone(), decide(joined)).await.status(),
+        StatusCode::NOT_FOUND
+    );
+    let id = created["id"].as_str().unwrap().to_owned();
+    let remove = || {
+        Request::delete(format!("/api/v2/libraries/{library}/credit-decisions/{id}"))
+            .body(Body::empty())
+            .unwrap()
+    };
+    assert_eq!(
+        send(listening.clone(), remove()).await.status(),
+        StatusCode::NOT_FOUND
+    );
+    assert_eq!(
+        send(managing.clone(), remove()).await.status(),
+        StatusCode::NO_CONTENT
+    );
+    assert_eq!(
+        send(managing.clone(), remove()).await.status(),
+        StatusCode::NOT_FOUND
+    );
+
+    // Undone, the credit can be decided again; a part of it is no candidate.
+    assert_eq!(
+        send(managing.clone(), decide(joined)).await.status(),
+        StatusCode::CREATED
+    );
+    let keep = json_request(
+        &format!("/api/v2/libraries/{library}/credit-decisions"),
+        json!({ "artist_id": shelf.artist("Chris Lake").await, "decision": "keep" }),
+    );
+    assert_eq!(
+        send(managing.clone(), keep).await.status(),
+        StatusCode::UNPROCESSABLE_ENTITY
+    );
+}
+
+#[tokio::test]
+async fn a_second_decision_on_one_credit_is_a_conflict() {
+    let shelf = shelf("conflict").await;
+    shelf.apply(&file(0, "Jonas Blue, Malive", Some("A"))).await;
+    shelf.settle().await;
+    let joined = shelf.artist("Jonas Blue, Malive").await;
+    let services = &shelf.state.services;
+    services
+        .decide_credit(shelf.owner, shelf.library, joined, CreditDecisionKind::Keep)
+        .await
+        .unwrap();
+    let again = services
+        .decide_credit(
+            shelf.owner,
+            shelf.library,
+            joined,
+            CreditDecisionKind::Split,
+        )
+        .await;
+    assert!(
+        matches!(
+            again,
+            Err(waveflow_server::services::ServiceError::Conflict)
+        ),
+        "{again:?}"
+    );
+}
+
+#[tokio::test]
+async fn each_track_category_lists_what_its_criterion_names() {
+    let shelf = shelf("categories").await;
+    let mut tracks = Vec::new();
+    // A gap on disc one: 1, 2, 4.
+    for (index, number) in [(0, 1), (1, 2), (2, 4)] {
+        let mut input = file(index, "Gap Band", Some("Gaps"));
+        input.track_number = Some(number);
+        tracks.push(input);
+    }
+    // Two tracks numbered 1 on the same disc.
+    for index in [3, 4] {
+        let mut input = file(index, "Dup Band", Some("Dups"));
+        input.track_number = Some(1);
+        tracks.push(input);
+    }
+    // Two years on one album.
+    for (index, year) in [(5, 2001), (6, 2002)] {
+        let mut input = file(index, "Year Band", Some("Years"));
+        input.year = Some(year);
+        tracks.push(input);
+    }
+    // No year, no number, no album.
+    let mut bare = file(7, "Bare Band", None);
+    bare.year = None;
+    bare.track_number = None;
+    tracks.push(bare);
+    // The same recording twice, a second apart.
+    for (index, album, duration) in [(8, "First", 180_000), (9, "Second", 181_000)] {
+        let mut input = file(index, "Echo Band", Some(album));
+        input.title = "Echo".into();
+        input.duration_ms = duration;
+        tracks.push(input);
+    }
+    // A compilation that names no album artist.
+    let mut various = file(10, "Some Band", Some("Hits"));
+    various.is_compilation = true;
+    tracks.push(various);
+    for input in &tracks {
+        shelf.apply(input).await;
+    }
+    shelf.settle().await;
+
+    let listed = |category: AttentionCategory| {
+        let shelf = &shelf;
+        async move {
+            let mut paths: Vec<String> = shelf
+                .state
+                .services
+                .attention_tracks(
+                    shelf.owner,
+                    shelf.library,
+                    category,
+                    BrowsePage::new(None, None).unwrap(),
+                )
+                .await
+                .unwrap()
+                .into_iter()
+                .map(|track| track.song.relative_path)
+                .collect();
+            paths.sort();
+            paths
+        }
+    };
+    let paths = |indices: &[usize]| -> Vec<String> {
+        let mut paths: Vec<String> = indices
+            .iter()
+            .map(|index| format!("track-{index}.flac"))
+            .collect();
+        paths.sort();
+        paths
+    };
+    assert_eq!(
+        listed(AttentionCategory::TrackNumberGap).await,
+        paths(&[0, 1, 2])
+    );
+    assert_eq!(
+        listed(AttentionCategory::DuplicateTrackNumber).await,
+        paths(&[3, 4])
+    );
+    assert_eq!(
+        listed(AttentionCategory::AlbumYearConflict).await,
+        paths(&[5, 6])
+    );
+    assert_eq!(listed(AttentionCategory::MissingYear).await, paths(&[7]));
+    assert_eq!(
+        listed(AttentionCategory::MissingTrackNumber).await,
+        paths(&[7])
+    );
+    assert_eq!(listed(AttentionCategory::MissingAlbum).await, paths(&[7]));
+    assert_eq!(
+        listed(AttentionCategory::ProbableDuplicate).await,
+        paths(&[8, 9])
+    );
+    assert_eq!(
+        listed(AttentionCategory::CompilationNoAlbumArtist).await,
+        paths(&[10])
+    );
+    assert!(listed(AttentionCategory::MissingArtist).await.is_empty());
+    assert_eq!(
+        listed(AttentionCategory::MissingCover).await.len(),
+        tracks.len(),
+        "no file here carries a cover"
+    );
+
+    // A correction is an effective value: the corrected track leaves its
+    // category at once, with no rescan.
+    let bare: String =
+        sqlx::query_scalar("SELECT id FROM track WHERE library_id = ? AND relative_path = ?")
+            .bind(shelf.library.to_string())
+            .bind("track-7.flac")
+            .fetch_one(shelf.state.db.pool())
+            .await
+            .unwrap();
+    shelf
+        .state
+        .services
+        .set_track_metadata(
+            shelf.owner,
+            Uuid::parse_str(&bare).unwrap(),
+            TrackMetadataPatch {
+                year: Some(Some(1999)),
+                ..TrackMetadataPatch::default()
+            },
+            None,
+        )
+        .await
+        .unwrap();
+    assert!(listed(AttentionCategory::MissingYear).await.is_empty());
+
+    let summary = shelf
+        .state
+        .services
+        .attention_summary(shelf.owner, shelf.library)
+        .await
+        .unwrap();
+    let count = |category: AttentionCategory| {
+        summary
+            .iter()
+            .find(|entry| entry.category == category)
+            .map(|entry| entry.count)
+    };
+    assert_eq!(summary.len(), AttentionCategory::ALL.len());
+    assert_eq!(summary[0].category, AttentionCategory::SplitCredits);
+    assert_eq!(count(AttentionCategory::TrackNumberGap), Some(3));
+    assert_eq!(count(AttentionCategory::ProbableDuplicate), Some(2));
+    assert_eq!(count(AttentionCategory::MissingYear), Some(0));
+
+    let duplicates = shelf
+        .state
+        .services
+        .attention_tracks(
+            shelf.owner,
+            shelf.library,
+            AttentionCategory::ProbableDuplicate,
+            BrowsePage::new(None, None).unwrap(),
+        )
+        .await
+        .unwrap();
+    assert!(
+        duplicates
+            .iter()
+            .all(|track| track.duplicate_group == Some(1)),
+        "both are one group"
+    );
+}
diff --git a/webapp/e2e/studio-nocturne.spec.ts b/webapp/e2e/studio-nocturne.spec.ts
index 67313680..d7167c03 100644
--- a/webapp/e2e/studio-nocturne.spec.ts
+++ b/webapp/e2e/studio-nocturne.spec.ts
@@ -3432,16 +3432,17 @@ test("opens the rest of the client from the mobile bar", async ({
 
   const sheet = page.getByRole("dialog");
   await expect(sheet).toBeVisible();
-  // The twelve the bar cannot hold — including the two this account is
-  // entitled to as an administrator of a library that takes files. `Radio`
-  // joined them with #217, and `Folders` with RFC-012's filed folders; this count
-  // is what said so: a new entry in the sidebar reaches the sheet, and the
-  // sheet is pinned.
+  // The thirteen the bar cannot hold — including the three this account is
+  // entitled to as an administrator and owner of a library that takes files.
+  // `Radio` joined them with #217, `Folders` with RFC-012's filed folders and
+  // `Needs attention` with RFC-015; this count is what said so: a new entry in
+  // the sidebar reaches the sheet, and the sheet is pinned.
   for (const name of [
     "Artists",
     "Songs",
     "Genres",
     "Folders",
+    "Needs attention",
     "Settings",
     "Random",
     "Recently played",
@@ -3455,7 +3456,7 @@ test("opens the rest of the client from the mobile bar", async ({
   }
   // Counted as well as named: a sheet that also offered something nobody asked
   // for would satisfy every line above.
-  await expect(sheet.getByRole("link")).toHaveCount(12);
+  await expect(sheet.getByRole("link")).toHaveCount(13);
 
   await expectNoWcagViolations(page);
 
@@ -3494,6 +3495,10 @@ test("offers nothing in the sheet that the account may not reach", async ({
   await expect(sheet.getByRole("link", { name: "Shares" })).toBeVisible();
   await expect(sheet.getByRole("link", { name: "Admin" })).toHaveCount(0);
   await expect(sheet.getByRole("link", { name: "Upload" })).toHaveCount(0);
+  // Nothing on it is a listener's to decide (RFC-015).
+  await expect(
+    sheet.getByRole("link", { name: "Needs attention" }),
+  ).toHaveCount(0);
 });
 
 /** A tab switch keeps the current screen until the destination can render. */
@@ -5603,3 +5608,231 @@ test("chooses an artist's portrait from a Deezer search", async ({ page }) => {
   expect(searches).toEqual(["Björk", "Nobody", "Bjork", "Bjork"]);
   expect(thirdParty).toEqual([]);
 });
+
+/**
+ * "Needs attention" (RFC-015), as the server answers it: the lists and their
+ * counts, the joined credits with the fragments the library already knows,
+ * and the decisions. Held here so a test can watch what the page writes.
+ */
+async function serveAttention(page: Page) {
+  const state = {
+    candidates: [
+      {
+        artist_id: "artist-joined",
+        name: "Ashreveal, Ashish Swargiary",
+        track_count: 1,
+        fragments: [
+          { name: "Ashreveal", artist_id: "artist-known", album_count: 2 },
+          { name: "Ashish Swargiary", artist_id: null, album_count: 0 },
+        ],
+      },
+    ],
+    decisions: [] as Array<Record<string, unknown>>,
+    writes: [] as Array<{ method: string; path: string; body: unknown }>,
+    asks: 0,
+  };
+  const base = "**/api/v2/libraries/library-1";
+  await page.route(`${base}/attention`, (route) => {
+    state.asks += 1;
+    return route.fulfill({
+      json: [
+        { category: "split_credits", count: state.candidates.length },
+        { category: "missing_artist", count: 0 },
+        { category: "missing_album", count: 0 },
+        { category: "missing_year", count: 1 },
+        { category: "missing_track_number", count: 0 },
+        { category: "missing_cover", count: 0 },
+        { category: "album_year_conflict", count: 0 },
+        { category: "compilation_no_album_artist", count: 0 },
+        { category: "duplicate_track_number", count: 0 },
+        { category: "track_number_gap", count: 0 },
+        { category: "probable_duplicate", count: 0 },
+      ],
+    });
+  });
+  await page.route(`${base}/attention/credits`, (route) =>
+    route.fulfill({ json: state.candidates }),
+  );
+  await page.route(`${base}/attention/tracks?*`, (route) => {
+    const category = new URL(route.request().url()).searchParams.get(
+      "category",
+    );
+    return route.fulfill({
+      json: category === "missing_year" ? [song(4, "Yearless", 0, false)] : [],
+    });
+  });
+  await page.route(`${base}/credit-decisions`, async (route) => {
+    const request = route.request();
+    if (request.method() === "GET") {
+      await route.fulfill({ json: state.decisions });
+      return;
+    }
+    const body = request.postDataJSON();
+    state.writes.push({ method: "POST", path: "credit-decisions", body });
+    const candidate = state.candidates.find(
+      (entry) => entry.artist_id === body.artist_id,
+    );
+    state.candidates = state.candidates.filter(
+      (entry) => entry.artist_id !== body.artist_id,
+    );
+    const decision = {
+      id: "decision-1",
+      credit: candidate?.name ?? "?",
+      decision: body.decision,
+      ...(body.decision === "split"
+        ? { parts: candidate?.fragments.map((fragment) => fragment.name) }
+        : {}),
+      decided_by: "listener",
+      decided_at: 1_700_000_000_000,
+    };
+    state.decisions = [decision];
+    await route.fulfill({ status: 201, json: decision });
+  });
+  await page.route(`${base}/credit-decisions/*`, async (route) => {
+    const request = route.request();
+    state.writes.push({
+      method: request.method(),
+      path: new URL(request.url()).pathname.split("/").at(-1) ?? "",
+      body: null,
+    });
+    state.decisions = [];
+    await route.fulfill({ status: 204, body: "" });
+  });
+  return state;
+}
+
+test("lists what needs attention, splits a credit on the second click, and undoes it", async ({
+  page,
+}) => {
+  const state = await serveAttention(page);
+  await page.goto("/attention");
+  await expect(
+    page.getByRole("heading", { name: "Needs attention" }),
+  ).toBeVisible();
+  await expect(page.getByText("2 things to look at")).toBeVisible();
+  // The first list holding something is open, and an empty one stays drawn.
+  const lists = page.getByRole("list", { name: "Lists" });
+  await expect(
+    lists.getByRole("link", { name: /Artists to split/ }),
+  ).toHaveAttribute("aria-current", "page");
+  await expect(lists.getByRole("link", { name: /Missing cover/ })).toHaveClass(
+    /empty/,
+  );
+
+  // A fragment the library already knows leads to that artist.
+  const fragments = page.getByRole("list", {
+    name: "What Ashreveal, Ashish Swargiary would split into",
+  });
+  await expect(
+    fragments.getByRole("link", { name: "Ashreveal" }),
+  ).toHaveAttribute("href", "/artists/artist-known");
+  await expect(fragments.getByText("Ashish Swargiary")).toBeVisible();
+
+  // The first click arms, and sends nothing.
+  await page.getByRole("button", { name: "Split", exact: true }).click();
+  const confirm = page.getByRole("button", { name: "Confirm: split into 2" });
+  await expect(confirm).toBeVisible();
+  expect(state.writes).toEqual([]);
+  await expectNoWcagViolations(page);
+  await confirm.click();
+  await expect(
+    page.getByText("Ashreveal, Ashish Swargiary is split."),
+  ).toBeVisible();
+  expect(state.writes).toEqual([
+    {
+      method: "POST",
+      path: "credit-decisions",
+      body: { artist_id: "artist-joined", decision: "split" },
+    },
+  ]);
+  await expect(
+    page.getByText("No credit is waiting for a decision."),
+  ).toBeVisible();
+
+  // Decided, then undone.
+  await page.getByRole("button", { name: "Decided" }).click();
+  await expect(
+    page.getByText("Split into Ashreveal · Ashish Swargiary"),
+  ).toBeVisible();
+  await page.getByRole("button", { name: "Undo" }).click();
+  await expect(
+    page.getByText("The decision about Ashreveal, Ashish Swargiary is undone."),
+  ).toBeVisible();
+  expect(state.writes.at(-1)).toEqual({
+    method: "DELETE",
+    path: "decision-1",
+    body: null,
+  });
+
+  // A track list opens its tracks in the song table.
+  await lists.getByRole("link", { name: /Missing year/ }).click();
+  await expect(page).toHaveURL(/category=missing_year/);
+  await expect(page.getByText("Yearless")).toBeVisible();
+  await expectNoWcagViolations(page);
+});
+
+/**
+ * A listener cannot act on any of it, so the page says so and asks nothing:
+ * the server would answer `404` regardless.
+ */
+test("asks nothing of the server for a listener's library", async ({
+  page,
+}) => {
+  libraries = [{ ...library("library-1", "Ma musique"), role: "listener" }];
+  const state = await serveAttention(page);
+  await page.goto("/attention");
+  await expect(
+    page.getByText(
+      "Only the owners and managers of this library see what needs attention in it.",
+    ),
+  ).toBeVisible();
+  // Settled before counting: the message and a request fired beside it
+  // arrive together, and a count taken first would be zero either way.
+  await page.waitForLoadState("networkidle");
+  expect(state.asks).toBe(0);
+});
+
+/** The desktop's other way in: from the joined artist's own page. */
+test("splits a joined artist from its page, after a confirming click", async ({
+  page,
+}) => {
+  const state = await serveAttention(page);
+  await page.route("**/api/v2/artists/artist-joined", (route) =>
+    route.fulfill({
+      json: {
+        ...artistDetail,
+        id: "artist-joined",
+        name: "Ashreveal, Ashish Swargiary",
+        library_id: "library-1",
+        album_count: 0,
+        albums: [],
+      },
+    }),
+  );
+  await page.route("**/api/v2/artists/artist-joined/*", (route) =>
+    route.fulfill({ json: [] }),
+  );
+  await page.goto("/artists/artist-joined");
+  const offer = page.getByRole("button", { name: "Split into 2 artists" });
+  await expect(offer).toBeVisible();
+  await offer.click();
+  await page.getByRole("button", { name: "Confirm: split into 2" }).click();
+  await expect(page).toHaveURL(/\/artists$/);
+  expect(state.writes).toEqual([
+    {
+      method: "POST",
+      path: "credit-decisions",
+      body: { artist_id: "artist-joined", decision: "split" },
+    },
+  ]);
+
+  // A listener is offered nothing.
+  libraries = [{ ...library("library-1", "Ma musique"), role: "listener" }];
+  await page.goto("/artists/artist-joined");
+  await expect(
+    page.getByRole("heading", { name: "Ashreveal, Ashish Swargiary" }),
+  ).toBeVisible();
+  await expect(
+    page.getByRole("button", { name: "Split into 2 artists" }),
+  ).toHaveCount(0);
+});
diff --git a/webapp/src/api/attention.ts b/webapp/src/api/attention.ts
new file mode 100644
index 00000000..faab2aff
--- /dev/null
+++ b/webapp/src/api/attention.ts
@@ -0,0 +1,107 @@
+import type { Song } from "./catalog";
+import { call } from "./client";
+
+/**
+ * "Needs attention" (RFC-015): what a library's owners and managers are asked
+ * to look at. The joined credits waiting for a split-or-keep decision, and the
+ * desktop's track categories the server can compute and act on.
+ */
+export type AttentionCategory =
+  | "split_credits"
+  | "missing_artist"
+  | "missing_album"
+  | "missing_year"
+  | "missing_track_number"
+  | "missing_cover"
+  | "album_year_conflict"
+  | "compilation_no_album_artist"
+  | "duplicate_track_number"
+  | "track_number_gap"
+  | "probable_duplicate";
+
+/** A track category: every category but the credits. */
+export type TrackCategory = Exclude<AttentionCategory, "split_credits">;
+
+export type AttentionCount = { category: AttentionCategory; count: number };
+
+/** One fragment of a joined credit, and the artist it would land on. */
+export type CreditFragment = {
+  name: string;
+  /** Set when the library already has an artist of that name. */
+  artist_id: string | null;
+  album_count: number;
+};
+
+/** A joined credit with no decision yet. */
+export type CreditCandidate = {
+  artist_id: string;
+  name: string;
+  track_count: number;
+  fragments: CreditFragment[];
+};
+
+export type CreditDecisionKind = "split" | "keep";
+
+export type CreditDecision = {
+  id: string;
+  /** The credit as it read when the decision was taken. */
+  credit: string;
+  decision: CreditDecisionKind;
+  /** What a split credits instead; absent for a keep. */
+  parts?: string[];
+  /** Who decided, by username; `null` once that account is gone. */
+  decided_by: string | null;
+  decided_at: number;
+};
+
+/** A track in one category; a probable duplicate names its group. */
+export type AttentionTrack = Song & { duplicate_group?: number };
+
+/** How many tracks one page of a category carries. */
+export const ATTENTION_TRACKS_PAGE = 200;
+
+export const getAttentionSummary = (libraryId: string) =>
+  call<AttentionCount[]>(`/api/v2/libraries/${libraryId}/attention`);
+
+export const listCreditCandidates = (libraryId: string) =>
+  call<CreditCandidate[]>(`/api/v2/libraries/${libraryId}/attention/credits`);
+
+export const listAttentionTracks = (
+  libraryId: string,
+  category: TrackCategory,
+  offset: number,
+  limit = ATTENTION_TRACKS_PAGE,
+  signal?: AbortSignal,
+) =>
+  call<AttentionTrack[]>(
+    `/api/v2/libraries/${libraryId}/attention/tracks?${new URLSearchParams({
+      category,
+      offset: String(offset),
+      limit: String(limit),
+    })}`,
+    { signal },
+  );
+
+export const listCreditDecisions = (libraryId: string) =>
+  call<CreditDecision[]>(`/api/v2/libraries/${libraryId}/credit-decisions`);
+
+/**
+ * Splits the credit an artist makes, or keeps it whole. The server applies it
+ * at once and to every later scan; `409` when the credit is already decided,
+ * `422` when it has nothing to split.
+ */
+export const decideCredit = (
+  libraryId: string,
+  artistId: string,
+  decision: CreditDecisionKind,
+) =>
+  call<CreditDecision>(`/api/v2/libraries/${libraryId}/credit-decisions`, {
+    method: "POST",
+    body: JSON.stringify({ artist_id: artistId, decision }),
+  });
+
+/** Undoes a decision: the library reads as if it had never been taken. */
+export const removeCreditDecision = (libraryId: string, decisionId: string) =>
+  call<void>(`/api/v2/libraries/${libraryId}/credit-decisions/${decisionId}`, {
+    method: "DELETE",
+  });
diff --git a/webapp/src/api/index.ts b/webapp/src/api/index.ts
index 3d5d7c20..9647149b 100644
--- a/webapp/src/api/index.ts
+++ b/webapp/src/api/index.ts
@@ -17,6 +17,25 @@ export {
   rotateOwnSubsonicCredential,
 } from "./account";
 export { artworkUrl, cachedArtworkUrl } from "./artwork";
+export type {
+  AttentionCategory,
+  AttentionCount,
+  AttentionTrack,
+  CreditCandidate,
+  CreditDecision,
+  CreditDecisionKind,
+  CreditFragment,
+  TrackCategory,
+} from "./attention";
+export {
+  ATTENTION_TRACKS_PAGE,
+  decideCredit,
+  getAttentionSummary,
+  listAttentionTracks,
+  listCreditCandidates,
+  listCreditDecisions,
+  removeCreditDecision,
+} from "./attention";
 export type { CanvasBlob } from "./canvas";
 export { canvasUrl, placeCanvas, removeCanvas } from "./canvas";
 export type {
diff --git a/webapp/src/api/queries.ts b/webapp/src/api/queries.ts
index 84243e7b..4271c758 100644
--- a/webapp/src/api/queries.ts
+++ b/webapp/src/api/queries.ts
@@ -3,11 +3,13 @@ import { playsByInstant, scrobbleRows, tracksToName } from "../lib/scrobbling";
 import {
   type AlbumSort,
   type ArtistDetail,
+  ATTENTION_TRACKS_PAGE,
   artistTopSongs,
   canvasUrl,
   FOLDER_TRACKS_PAGE,
   getAlbum,
   getArtist,
+  getAttentionSummary,
   getLyrics,
   getTrack,
   getTrackCredits,
@@ -17,7 +19,10 @@ import {
   listApiTokens,
   listArtistAlbums,
   listArtists,
+  listAttentionTracks,
   listBookmarks,
+  listCreditCandidates,
+  listCreditDecisions,
   listFavorites,
   listFolders,
   listFolderTracks,
@@ -41,6 +46,7 @@ import {
   SONG_PAGE,
   type SongSort,
   search,
+  type TrackCategory,
 } from "./index";
 
 /**
@@ -215,6 +221,51 @@ export const trackPropertiesQuery = (trackId: string) =>
  * A library's whole filed tree: bounded by the server's folder cap, so it
  * is held whole rather than paged.
  */
+/**
+ * "Needs attention" (RFC-015): every query of the page is keyed under
+ * `attention` and the library, so one invalidation after a decision, a
+ * correction or a scan refreshes the whole page.
+ */
+export const attentionSummaryQuery = (libraryId: string) =>
+  queryOptions({
+    queryKey: ["attention", libraryId, "summary"],
+    queryFn: () => getAttentionSummary(libraryId),
+  });
+
+export const creditCandidatesQuery = (libraryId: string) =>
+  queryOptions({
+    queryKey: ["attention", libraryId, "credits"],
+    queryFn: () => listCreditCandidates(libraryId),
+  });
+
+export const creditDecisionsQuery = (libraryId: string) =>
+  queryOptions({
+    queryKey: ["attention", libraryId, "decisions"],
+    queryFn: () => listCreditDecisions(libraryId),
+  });
+
+/** The tracks of one category, a page at a time. A short page is the end. */
+export const attentionTracksQuery = (
+  libraryId: string,
+  category: TrackCategory,
+) =>
+  infiniteQueryOptions({
+    queryKey: ["attention", libraryId, "tracks", category],
+    queryFn: ({ pageParam, signal }) =>
+      listAttentionTracks(
+        libraryId,
+        category,
+        pageParam,
+        ATTENTION_TRACKS_PAGE,
+        signal,
+      ),
+    initialPageParam: 0,
+    getNextPageParam: (last, _pages, lastParam) =>
+      last.length < ATTENTION_TRACKS_PAGE
+        ? undefined
+        : lastParam + ATTENTION_TRACKS_PAGE,
+  });
+
 export const filedTreeQuery = (libraryId: string) =>
   queryOptions({
     queryKey: ["filed-tree", libraryId],
diff --git a/webapp/src/components/artist-split.tsx b/webapp/src/components/artist-split.tsx
new file mode 100644
index 00000000..f9fa0e73
--- /dev/null
+++ b/webapp/src/components/artist-split.tsx
@@ -0,0 +1,74 @@
+import { useQueryClient } from "@tanstack/react-query";
+import { useNavigate } from "@tanstack/react-router";
+import { useEffect, useState } from "react";
+
+import { type ArtistDetail, decideCredit } from "../api";
+import { creditFragments } from "../lib/credit-fragments";
+import { useI18n } from "../state/i18n";
+
+/** How long the offer waits for its confirming click, as on the desktop. */
+const CONFIRM_MS = 4000;
+
+/**
+ * The desktop's other way into a split (RFC-015): from the artist page of a
+ * joined credit, for the library's owners and managers. The first click arms
+ * it and says into how many; a second within four seconds splits.
+ *
+ * Split, this artist no longer exists — its tracks now credit the parts — so
+ * the page leaves for the artists list rather than staying on a `404`. The
+ * decision can be undone from "Needs attention".
+ */
+export function ArtistSplit({ artist }: { artist: ArtistDetail }) {
+  const { t } = useI18n();
+  const client = useQueryClient();
+  const navigate = useNavigate();
+  const parts = creditFragments(artist.name);
+  const [armed, setArmed] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [failed, setFailed] = useState(false);
+  useEffect(() => {
+    if (!armed) return;
+    const timer = window.setTimeout(() => setArmed(false), CONFIRM_MS);
+    return () => window.clearTimeout(timer);
+  }, [armed]);
+
+  async function split() {
+    setBusy(true);
+    setFailed(false);
+    try {
+      await decideCredit(artist.library_id, artist.id, "split");
+      await client.invalidateQueries();
+      await navigate({ to: "/artists" });
+    } catch {
+      setFailed(true);
+      setBusy(false);
+    }
+  }
+
+  return (
+    <div className="artist-split">
+      <button
+        type="button"
+        className={`artist-image-button${armed ? " armed" : ""}`}
+        disabled={busy}
+        onClick={() => {
+          if (armed) {
+            setArmed(false);
+            void split();
+          } else {
+            setArmed(true);
+          }
+        }}
+      >
+        {t(armed ? "artistSplit.confirm" : "artistSplit.offer", {
+          count: parts.length,
+        })}
+      </button>
+      {failed ? (
+        <p className="error" role="alert">
+          {t("artistSplit.failed")}
+        </p>
+      ) : null}
+    </div>
+  );
+}
diff --git a/webapp/src/lib/credit-fragments.test.ts b/webapp/src/lib/credit-fragments.test.ts
new file mode 100644
index 00000000..13a83f2f
--- /dev/null
+++ b/webapp/src/lib/credit-fragments.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+
+import { creditFragments, isSplitCandidate } from "./credit-fragments";
+
+describe("credit fragments", () => {
+  it("cuts on the desktop's four commas", () => {
+    expect(creditFragments("Ashreveal, Ashish Swargiary")).toEqual([
+      "Ashreveal",
+      "Ashish Swargiary",
+    ]);
+    expect(creditFragments("蔡依林，周杰伦")).toEqual(["蔡依林", "周杰伦"]);
+    expect(creditFragments("庄心妍、祁隆")).toEqual(["庄心妍", "祁隆"]);
+    expect(creditFragments("A､B, C")).toEqual(["A", "B", "C"]);
+  });
+
+  it("never cuts inside parentheses", () => {
+    expect(creditFragments("Ian Asher, Olly Alexander (Years, Years)")).toEqual(
+      ["Ian Asher", "Olly Alexander (Years, Years)"],
+    );
+  });
+
+  it("keeps the first spelling of a repeated name", () => {
+    expect(creditFragments("A, B, a")).toEqual(["A", "B"]);
+  });
+
+  it("offers a split only where the server lists one", () => {
+    expect(isSplitCandidate("Zedd, Alessia Cara")).toBe(true);
+    expect(isSplitCandidate("Tyler, The Creator")).toBe(true);
+    expect(isSplitCandidate("Solo,")).toBe(false);
+    expect(isSplitCandidate("Simon & Garfunkel")).toBe(false);
+    expect(isSplitCandidate("A, a")).toBe(false);
+  });
+});
diff --git a/webapp/src/lib/credit-fragments.ts b/webapp/src/lib/credit-fragments.ts
new file mode 100644
index 00000000..4aeb26bb
--- /dev/null
+++ b/webapp/src/lib/credit-fragments.ts
@@ -0,0 +1,55 @@
+/**
+ * How the server cuts a joined artist credit (RFC-015 decision 2), for the
+ * one place the client needs to know before asking: whether the artist page
+ * offers "Split into N artists" at all. The server decides regardless — a
+ * credit it does not take for a candidate answers `422`.
+ *
+ * The desktop's four characters, never inside parentheses, each fragment
+ * trimmed, blanks dropped, duplicates dropped on a folded name with the first
+ * spelling kept.
+ */
+const SEPARATORS = new Set([",", "，", "、", "､"]);
+
+/** Close to the server's canonical name: case, accents and punctuation go. */
+function canonical(value: string) {
+  return value
+    .normalize("NFD")
+    .replace(/\p{Diacritic}/gu, "")
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, " ")
+    .trim();
+}
+
+export function creditFragments(name: string): string[] {
+  const parts: string[] = [];
+  let depth = 0;
+  let current = "";
+  for (const character of name) {
+    if (character === "(") depth += 1;
+    if (character === ")") depth = Math.max(0, depth - 1);
+    if (depth === 0 && SEPARATORS.has(character)) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += character;
+    }
+  }
+  parts.push(current);
+  const seen = new Set<string>();
+  return parts
+    .map((part) => part.trim())
+    .filter((part) => {
+      if (!part) return false;
+      const key = canonical(part);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+}
+
+/** Whether the server would list the credit: two fragments, none the whole. */
+export function isSplitCandidate(name: string): boolean {
+  const parts = creditFragments(name);
+  const whole = canonical(name);
+  return parts.length >= 2 && parts.every((part) => canonical(part) !== whole);
+}
diff --git a/webapp/src/main.tsx b/webapp/src/main.tsx
index 439dad49..f8c080dd 100644
--- a/webapp/src/main.tsx
+++ b/webapp/src/main.tsx
@@ -56,6 +56,7 @@ import { AlbumPage } from "./pages/album-page";
 import { AlbumsPage } from "./pages/albums-page";
 import { ArtistPage } from "./pages/artist-page";
 import { ArtistsPage } from "./pages/artists-page";
+import { AttentionPage, isAttentionCategory } from "./pages/attention-page";
 import { AuthorizePage } from "./pages/authorize-page";
 import { FavoritesPage } from "./pages/favorites-page";
 import { FoldersPage } from "./pages/folders-page";
@@ -80,6 +81,7 @@ import { I18nProvider, type TranslationKey, useI18n } from "./state/i18n";
 import {
   LibraryPicker,
   LibraryScopeProvider,
+  mayCorrectTracks,
   mayUploadTo,
   useLibraryScope,
 } from "./state/library-scope";
@@ -117,6 +119,7 @@ const navigation: Array<{
     | "/artists"
     | "/songs"
     | "/folders"
+    | "/attention"
     | "/genres"
     | "/search"
     | "/favourites"
@@ -136,6 +139,8 @@ const navigation: Array<{
   admin?: boolean;
   /** Shown only where the active library takes files from this account. */
   upload?: boolean;
+  /** Shown only to the active library's owners and managers. */
+  curate?: boolean;
   primary?: boolean;
   /** The rail section it is filed under. */
   group: NavigationGroup;
@@ -156,6 +161,13 @@ const navigation: Array<{
     icon: "folder",
     group: "library",
   },
+  {
+    to: "/attention",
+    labelKey: "nav.attention",
+    icon: "info",
+    curate: true,
+    group: "library",
+  },
   {
     to: "/search",
     labelKey: "nav.search",
@@ -299,6 +311,8 @@ async function prepareTab(
     // The folder is in the address, and the rail links to the root: the
     // page draws its own frame and waits for its folder there.
     case "/folders":
+    // Its lists are asked for once the page knows the active library.
+    case "/attention":
       break;
     // A fresh draw on every ask, held for no time at all: a draw made here
     // is thrown away before the page mounts, and the page then draws again.
@@ -340,7 +354,9 @@ function permitted(
   library: Parameters<typeof mayUploadTo>[0],
 ): boolean {
   return (
-    (!item.admin || role === "admin") && (!item.upload || mayUploadTo(library))
+    (!item.admin || role === "admin") &&
+    (!item.upload || mayUploadTo(library)) &&
+    (!item.curate || mayCorrectTracks(library ?? undefined))
   );
 }
 
@@ -873,6 +889,22 @@ const foldersRoute = createRoute({
   },
 });
 
+// The open list is a search parameter, so a list can be linked to and the
+// back button walks between them.
+const attentionRoute = createRoute({
+  getParentRoute: () => authedRoute,
+  path: "/attention",
+  validateSearch: (search: Record<string, unknown>) => ({
+    category: isAttentionCategory(search.category)
+      ? search.category
+      : undefined,
+  }),
+  component: function AttentionRoute() {
+    const { category } = attentionRoute.useSearch();
+    return <AttentionPage category={category} />;
+  },
+});
+
 const uploadRoute = createRoute({
   getParentRoute: () => authedRoute,
   path: "/upload",
@@ -902,6 +934,7 @@ const routeTree = rootRoute.addChildren([
     albumRoute,
     songsRoute,
     foldersRoute,
+    attentionRoute,
     artistsRoute,
     artistRoute,
     genresRoute,
diff --git a/webapp/src/pages/artist-page.tsx b/webapp/src/pages/artist-page.tsx
index b8afeaaa..cee57c27 100644
--- a/webapp/src/pages/artist-page.tsx
+++ b/webapp/src/pages/artist-page.tsx
@@ -9,9 +9,11 @@ import {
 } from "../api/queries";
 import { AlbumGrid } from "../components/album-grid";
 import { ArtistImageControls } from "../components/artist-image-controls";
+import { ArtistSplit } from "../components/artist-split";
 import { Artwork } from "../components/artwork";
 import { Loading } from "../components/page-shell";
 import { SongTable } from "../components/song-table";
+import { isSplitCandidate } from "../lib/credit-fragments";
 import { useI18n } from "../state/i18n";
 import { mayCorrectTracks, useLibraryScope } from "../state/library-scope";
 
@@ -159,6 +161,11 @@ export function ArtistPage({ artistId }: { artistId: string }) {
           <p className="muted">
             {t("artists.libraryCount", { count: value.album_count })}
           </p>
+          {/* A joined credit, such as "Ashreveal, Ashish Swargiary" (RFC-015):
+              offered where the server would list it, to whoever may decide. */}
+          {mayChoose && isSplitCandidate(value.name) ? (
+            <ArtistSplit artist={value} />
+          ) : null}
           {value.image_choice?.portrait ? (
             <p className="muted artist-source">{t("artistImage.chosen")}</p>
           ) : image && image.artwork_hash === portrait ? (
diff --git a/webapp/src/pages/attention-page.tsx b/webapp/src/pages/attention-page.tsx
new file mode 100644
index 00000000..233836c5
--- /dev/null
+++ b/webapp/src/pages/attention-page.tsx
@@ -0,0 +1,443 @@
+import {
+  useInfiniteQuery,
+  useQuery,
+  useQueryClient,
+} from "@tanstack/react-query";
+import { Link, useNavigate } from "@tanstack/react-router";
+import { useEffect, useMemo, useState } from "react";
+
+import {
+  ApiError,
+  type AttentionCategory,
+  type CreditCandidate,
+  type CreditDecision,
+  decideCredit,
+  removeCreditDecision,
+  type TrackCategory,
+} from "../api";
+import {
+  attentionSummaryQuery,
+  attentionTracksQuery,
+  creditCandidatesQuery,
+  creditDecisionsQuery,
+} from "../api/queries";
+import { Loading, PageHeader } from "../components/page-shell";
+import { SongTable } from "../components/song-table";
+import { type TranslationKey, useI18n } from "../state/i18n";
+import { mayCorrectTracks, useLibraryScope } from "../state/library-scope";
+
+/** The page's lists, in the desktop's order, with what each is called. */
+const CATEGORIES: Array<{ key: AttentionCategory; label: TranslationKey }> = [
+  { key: "split_credits", label: "attention.split_credits" },
+  { key: "missing_artist", label: "attention.missing_artist" },
+  { key: "missing_album", label: "attention.missing_album" },
+  { key: "missing_year", label: "attention.missing_year" },
+  { key: "missing_track_number", label: "attention.missing_track_number" },
+  { key: "missing_cover", label: "attention.missing_cover" },
+  { key: "album_year_conflict", label: "attention.album_year_conflict" },
+  {
+    key: "compilation_no_album_artist",
+    label: "attention.compilation_no_album_artist",
+  },
+  { key: "duplicate_track_number", label: "attention.duplicate_track_number" },
+  { key: "track_number_gap", label: "attention.track_number_gap" },
+  { key: "probable_duplicate", label: "attention.probable_duplicate" },
+];
+
+/** How long a Split waits for the second click, as on the desktop. */
+const CONFIRM_MS = 4000;
+
+export function isAttentionCategory(
+  value: unknown,
+): value is AttentionCategory {
+  return CATEGORIES.some((entry) => entry.key === value);
+}
+
+/**
+ * "Needs attention" (RFC-015 decision 8): what a library's owners and
+ * managers are asked to look at. The joined credits waiting for a decision —
+ * split into the artists they name, or kept whole — and the desktop's track
+ * categories the server can compute. A track category offers no action of
+ * its own: it opens its tracks in the song table, whose menu holds the editor.
+ *
+ * The rail shows no count. A number that moves after every scan, in a corner
+ * of every page, would be a notification nobody asked for; the sum is said
+ * here, at the top of the page it belongs to.
+ */
+export function AttentionPage({
+  category,
+}: {
+  category: AttentionCategory | undefined;
+}) {
+  const { t } = useI18n();
+  const { active, ready } = useLibraryScope();
+  const libraryId = active?.id ?? "";
+  const may = mayCorrectTracks(active ?? undefined);
+  const summary = useQuery({
+    ...attentionSummaryQuery(libraryId),
+    enabled: active !== null && may,
+  });
+  const counts = useMemo(
+    () =>
+      new Map(
+        (summary.data ?? []).map((entry) => [entry.category, entry.count]),
+      ),
+    [summary.data],
+  );
+  const total = summary.data?.reduce((sum, entry) => sum + entry.count, 0);
+  // Without one in the address, the first list holding something is open —
+  // and is then written into the address. Recomputed on every answer, the
+  // choice would move under the hand that just emptied the list: a split
+  // takes the last credit off "Artists to split", and the page would jump to
+  // the next list, notice and all.
+  const open: AttentionCategory | undefined =
+    category ??
+    CATEGORIES.find((entry) => (counts.get(entry.key) ?? 0) > 0)?.key;
+  const navigate = useNavigate();
+  useEffect(() => {
+    if (category === undefined && open !== undefined) {
+      void navigate({
+        to: "/attention",
+        search: { category: open },
+        replace: true,
+      });
+    }
+  }, [category, open, navigate]);
+
+  const header = (
+    <PageHeader
+      kicker={t("nav.group.library")}
+      title={t("nav.attention")}
+      detail={
+        total === undefined
+          ? undefined
+          : total === 0
+            ? t("attention.nothing")
+            : t("attention.total", { count: total })
+      }
+    />
+  );
+
+  if (ready && (!active || !may)) {
+    return (
+      <section>
+        {header}
+        <p className="muted">
+          {t(active ? "attention.notYours" : "folders.noLibrary")}
+        </p>
+      </section>
+    );
+  }
+
+  return (
+    <section className="attention-page">
+      {header}
+      {!summary.data ? (
+        <Loading error={summary.error} />
+      ) : (
+        <>
+          <ul
+            className="attention-categories"
+            aria-label={t("attention.lists")}
+          >
+            {CATEGORIES.map((entry) => {
+              const count = counts.get(entry.key) ?? 0;
+              return (
+                <li key={entry.key}>
+                  <Link
+                    to="/attention"
+                    search={{ category: entry.key }}
+                    className={`attention-category${count === 0 ? " empty" : ""}`}
+                    aria-current={open === entry.key ? "page" : undefined}
+                  >
+                    <span>{t(entry.label)}</span>
+                    <small className="attention-count">{count}</small>
+                  </Link>
+                </li>
+              );
+            })}
+          </ul>
+          {open === "split_credits" ? (
+            <CreditsPanel libraryId={libraryId} />
+          ) : open ? (
+            <TracksPanel libraryId={libraryId} category={open} />
+          ) : (
+            <p className="muted">{t("attention.nothing")}</p>
+          )}
+        </>
+      )}
+    </section>
+  );
+}
+
+function TracksPanel({
+  libraryId,
+  category,
+}: {
+  libraryId: string;
+  category: TrackCategory;
+}) {
+  const { t } = useI18n();
+  const tracks = useInfiniteQuery(attentionTracksQuery(libraryId, category));
+  const songs = useMemo(() => tracks.data?.pages.flat() ?? [], [tracks.data]);
+  if (!tracks.data) return <Loading error={tracks.error} />;
+  if (!songs.length) return <p className="muted">{t("attention.empty")}</p>;
+  return (
+    <>
+      <p className="muted attention-note">{t("attention.tracksNote")}</p>
+      <SongTable songs={songs} />
+      {tracks.hasNextPage ? (
+        <div className="actions">
+          <button
+            type="button"
+            onClick={() => tracks.fetchNextPage()}
+            disabled={tracks.isFetchingNextPage}
+          >
+            {tracks.isFetchingNextPage
+              ? t("songs.loading")
+              : t("songs.loadMore")}
+          </button>
+        </div>
+      ) : null}
+    </>
+  );
+}
+
+type Notice = { error: boolean; text: string } | null;
+
+function CreditsPanel({ libraryId }: { libraryId: string }) {
+  const { t } = useI18n();
+  const client = useQueryClient();
+  const [view, setView] = useState<"pending" | "decided">("pending");
+  const candidates = useQuery(creditCandidatesQuery(libraryId));
+  const decisions = useQuery({
+    ...creditDecisionsQuery(libraryId),
+    enabled: view === "decided",
+  });
+  const [busy, setBusy] = useState(false);
+  const [notice, setNotice] = useState<Notice>(null);
+
+  /**
+   * A decision moves credits everywhere an artist is read, so everything is
+   * re-read rather than a list of caches that might be missing one.
+   */
+  async function attempt(write: () => Promise<unknown>, said: string) {
+    setBusy(true);
+    setNotice(null);
+    try {
+      await write();
+      await client.invalidateQueries();
+      setNotice({ error: false, text: said });
+    } catch (error) {
+      setNotice({
+        error: true,
+        text: t(
+          error instanceof ApiError && error.status === 409
+            ? "attention.alreadyDecided"
+            : "attention.failed",
+        ),
+      });
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <div className="attention-credits">
+      <p className="muted attention-note">{t("attention.creditsNote")}</p>
+      <div className="attention-views">
+        <button
+          type="button"
+          aria-pressed={view === "pending"}
+          onClick={() => setView("pending")}
+        >
+          {t("attention.pending")}
+        </button>
+        <button
+          type="button"
+          aria-pressed={view === "decided"}
+          onClick={() => setView("decided")}
+        >
+          {t("attention.decided")}
+        </button>
+      </div>
+      {notice ? (
+        <p
+          className={notice.error ? "error" : "muted attention-notice"}
+          role={notice.error ? "alert" : "status"}
+        >
+          {notice.text}
+        </p>
+      ) : null}
+      {view === "pending" ? (
+        !candidates.data ? (
+          <Loading error={candidates.error} />
+        ) : candidates.data.length ? (
+          <ul className="attention-rows">
+            {candidates.data.map((candidate) => (
+              <CandidateRow
+                key={candidate.artist_id}
+                candidate={candidate}
+                busy={busy}
+                onSplit={() =>
+                  attempt(
+                    () => decideCredit(libraryId, candidate.artist_id, "split"),
+                    t("attention.splitDone", { name: candidate.name }),
+                  )
+                }
+                onKeep={() =>
+                  attempt(
+                    () => decideCredit(libraryId, candidate.artist_id, "keep"),
+                    t("attention.keepDone", { name: candidate.name }),
+                  )
+                }
+              />
+            ))}
+          </ul>
+        ) : (
+          <p className="muted">{t("attention.noCredits")}</p>
+        )
+      ) : !decisions.data ? (
+        <Loading error={decisions.error} />
+      ) : decisions.data.length ? (
+        <ul className="attention-rows">
+          {decisions.data.map((decision) => (
+            <DecisionRow
+              key={decision.id}
+              decision={decision}
+              busy={busy}
+              onUndo={() =>
+                attempt(
+                  () => removeCreditDecision(libraryId, decision.id),
+                  t("attention.undone", { name: decision.credit }),
+                )
+              }
+            />
+          ))}
+        </ul>
+      ) : (
+        <p className="muted">{t("attention.noDecisions")}</p>
+      )}
+    </div>
+  );
+}
+
+function CandidateRow({
+  candidate,
+  busy,
+  onSplit,
+  onKeep,
+}: {
+  candidate: CreditCandidate;
+  busy: boolean;
+  onSplit: () => Promise<void>;
+  onKeep: () => Promise<void>;
+}) {
+  const { t } = useI18n();
+  // Split asks twice: the first click arms it, a second within four seconds
+  // fires. Keep is undone as easily as it is done, so it asks once.
+  const [armed, setArmed] = useState(false);
+  useEffect(() => {
+    if (!armed) return;
+    const timer = window.setTimeout(() => setArmed(false), CONFIRM_MS);
+    return () => window.clearTimeout(timer);
+  }, [armed]);
+  return (
+    <li className="attention-row">
+      <div className="attention-row-main">
+        <Link
+          to="/artists/$artistId"
+          params={{ artistId: candidate.artist_id }}
+          className="attention-credit"
+        >
+          {candidate.name}
+        </Link>
+        <small className="muted">
+          {t("common.tracks", { count: candidate.track_count })}
+        </small>
+      </div>
+      <ul
+        className="attention-fragments"
+        aria-label={t("attention.fragments", { name: candidate.name })}
+      >
+        {candidate.fragments.map((fragment) => (
+          <li key={fragment.name}>
+            {fragment.artist_id ? (
+              <Link
+                to="/artists/$artistId"
+                params={{ artistId: fragment.artist_id }}
+                className="attention-fragment known"
+                title={t("attention.knownFragment")}
+              >
+                {fragment.name}
+              </Link>
+            ) : (
+              <span className="attention-fragment">{fragment.name}</span>
+            )}
+          </li>
+        ))}
+      </ul>
+      <div className="attention-actions">
+        <button
+          type="button"
+          className={armed ? "action-primary" : undefined}
+          disabled={busy}
+          onClick={() => {
+            if (armed) {
+              setArmed(false);
+              void onSplit();
+            } else {
+              setArmed(true);
+            }
+          }}
+        >
+          {armed
+            ? t("attention.confirmSplit", {
+                count: candidate.fragments.length,
+              })
+            : t("attention.split")}
+        </button>
+        <button type="button" disabled={busy} onClick={() => void onKeep()}>
+          {t("attention.keep")}
+        </button>
+      </div>
+    </li>
+  );
+}
+
+function DecisionRow({
+  decision,
+  busy,
+  onUndo,
+}: {
+  decision: CreditDecision;
+  busy: boolean;
+  onUndo: () => Promise<void>;
+}) {
+  const { t, locale } = useI18n();
+  const when = new Date(decision.decided_at).toLocaleDateString(locale);
+  return (
+    <li className="attention-row">
+      <div className="attention-row-main">
+        <span className="attention-credit">{decision.credit}</span>
+        <small className="muted">
+          {decision.decision === "split"
+            ? t("attention.decidedSplit", {
+                parts: (decision.parts ?? []).join(" · "),
+              })
+            : t("attention.decidedKeep")}
+        </small>
+        <small className="muted">
+          {decision.decided_by
+            ? t("attention.decidedBy", { who: decision.decided_by, when })
+            : when}
+        </small>
+      </div>
+      <div className="attention-actions">
+        <button type="button" disabled={busy} onClick={() => void onUndo()}>
+          {t("attention.undo")}
+        </button>
+      </div>
+    </li>
+  );
+}
diff --git a/webapp/src/state/i18n.tsx b/webapp/src/state/i18n.tsx
index 4426e224..fac55fe1 100644
--- a/webapp/src/state/i18n.tsx
+++ b/webapp/src/state/i18n.tsx
@@ -443,6 +443,55 @@ const en = {
   "nav.playing": "Now playing",
   "nav.upload": "Upload",
   "nav.folders": "Folders",
+  "nav.attention": "Needs attention",
+  "attention.lists": "Lists",
+  "attention.total": {
+    one: "{count} thing to look at",
+    other: "{count} things to look at",
+  },
+  "attention.nothing": "Nothing needs attention.",
+  "attention.notYours":
+    "Only the owners and managers of this library see what needs attention in it.",
+  "attention.empty": "Nothing in this list.",
+  "attention.tracksNote":
+    "Fix a track from its menu: once corrected, it leaves the list.",
+  "attention.creditsNote":
+    "Each of these credits names several artists in one string. Split it into the artists it names, or keep it as one when it is a single name. Every later scan applies the decision.",
+  "attention.pending": "To decide",
+  "attention.decided": "Decided",
+  "attention.split": "Split",
+  "attention.confirmSplit": "Confirm: split into {count}",
+  "attention.keep": "Keep as one",
+  "attention.splitDone": "{name} is split.",
+  "attention.keepDone": "{name} stays as one.",
+  "attention.undone": "The decision about {name} is undone.",
+  "attention.alreadyDecided":
+    "This credit was decided in the meantime. The list has been reloaded.",
+  "attention.failed": "That did not work. Try again.",
+  "attention.noCredits": "No credit is waiting for a decision.",
+  "attention.noDecisions": "Nothing has been decided yet.",
+  "attention.fragments": "What {name} would split into",
+  "attention.knownFragment": "Already an artist in this library",
+  "attention.decidedSplit": "Split into {parts}",
+  "attention.decidedKeep": "Kept as one",
+  "attention.decidedBy": "By {who}, {when}",
+  "attention.undo": "Undo",
+  "attention.split_credits": "Artists to split",
+  "attention.missing_artist": "Missing artist",
+  "attention.missing_album": "Missing album",
+  "attention.missing_year": "Missing year",
+  "attention.missing_track_number": "Missing track number",
+  "attention.missing_cover": "Missing cover",
+  "attention.album_year_conflict": "Albums with several years",
+  "attention.compilation_no_album_artist":
+    "Compilations without an album artist",
+  "attention.duplicate_track_number": "Duplicate track numbers",
+  "attention.track_number_gap": "Gaps in track numbers",
+  "attention.probable_duplicate": "Probable duplicates",
+  "artistSplit.offer": "Split into {count} artists",
+  "artistSplit.confirm": "Confirm: split into {count}",
+  "artistSplit.done": "Split into {parts}.",
+  "artistSplit.failed": "This credit could not be split. Try again.",
   "common.back": "Back",
   "artistImage.changePortrait": "Change portrait",
   "artistImage.changeBanner": "Change banner",
@@ -1158,6 +1207,54 @@ const fr: Record<TranslationKey, TranslationValue> = {
   "nav.playing": "En écoute",
   "nav.upload": "Téléverser",
   "nav.folders": "Dossiers",
+  "nav.attention": "À corriger",
+  "attention.lists": "Listes",
+  "attention.total": {
+    one: "{count} point à vérifier",
+    other: "{count} points à vérifier",
+  },
+  "attention.nothing": "Rien à corriger.",
+  "attention.notYours":
+    "Seuls les propriétaires et les gestionnaires de cette bibliothèque voient ce qui y est à corriger.",
+  "attention.empty": "Rien dans cette liste.",
+  "attention.tracksNote":
+    "Corrigez une piste depuis son menu : une fois corrigée, elle quitte la liste.",
+  "attention.creditsNote":
+    "Chacun de ces crédits nomme plusieurs artistes dans une seule chaîne. Scindez-le en ces artistes, ou gardez-le tel quel s’il s’agit d’un seul nom. Chaque scan suivant applique la décision.",
+  "attention.pending": "À décider",
+  "attention.decided": "Décidés",
+  "attention.split": "Scinder",
+  "attention.confirmSplit": "Confirmer : scinder en {count}",
+  "attention.keep": "Garder tel quel",
+  "attention.splitDone": "{name} est scindé.",
+  "attention.keepDone": "{name} reste tel quel.",
+  "attention.undone": "La décision sur {name} est annulée.",
+  "attention.alreadyDecided":
+    "Ce crédit a été décidé entre-temps. La liste a été rechargée.",
+  "attention.failed": "Cela n’a pas fonctionné. Réessayez.",
+  "attention.noCredits": "Aucun crédit n’attend de décision.",
+  "attention.noDecisions": "Aucune décision pour l’instant.",
+  "attention.fragments": "Ce en quoi {name} serait scindé",
+  "attention.knownFragment": "Déjà un artiste de cette bibliothèque",
+  "attention.decidedSplit": "Scindé en {parts}",
+  "attention.decidedKeep": "Gardé tel quel",
+  "attention.decidedBy": "Par {who}, le {when}",
+  "attention.undo": "Annuler",
+  "attention.split_credits": "Artistes à scinder",
+  "attention.missing_artist": "Sans artiste",
+  "attention.missing_album": "Sans album",
+  "attention.missing_year": "Sans année",
+  "attention.missing_track_number": "Sans numéro de piste",
+  "attention.missing_cover": "Sans pochette",
+  "attention.album_year_conflict": "Albums à plusieurs années",
+  "attention.compilation_no_album_artist": "Compilations sans artiste d’album",
+  "attention.duplicate_track_number": "Numéros de piste en double",
+  "attention.track_number_gap": "Trous dans la numérotation",
+  "attention.probable_duplicate": "Doublons probables",
+  "artistSplit.offer": "Scinder en {count} artistes",
+  "artistSplit.confirm": "Confirmer : scinder en {count}",
+  "artistSplit.done": "Scindé en {parts}.",
+  "artistSplit.failed": "Ce crédit n’a pas pu être scindé. Réessayez.",
   "common.back": "Retour",
   "artistImage.changePortrait": "Changer le portrait",
   "artistImage.changeBanner": "Changer la bannière",
diff --git a/webapp/src/styles/styles.css b/webapp/src/styles/styles.css
index e8eaa7e7..a407ac99 100644
--- a/webapp/src/styles/styles.css
+++ b/webapp/src/styles/styles.css
@@ -3067,6 +3067,146 @@ button.danger {
   vertical-align: middle;
 }
 
+/* "Needs attention" (RFC-015). The lists read as the folder cards do, one
+   per row of a wrapping grid; an empty list stays where it is, greyed, so the
+   page keeps its shape as lists empty, as on the desktop. */
+.attention-categories {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(min(100%, 14rem), 1fr));
+  gap: var(--space-2);
+  margin: 0 0 var(--space-6);
+  padding: 0;
+  list-style: none;
+}
+
+.attention-category {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--space-3);
+  padding: var(--space-3);
+  border: 1px solid var(--line);
+  border-radius: 0.7rem;
+  background: var(--panel-soft);
+  transition:
+    border-color 180ms ease,
+    background-color 180ms ease;
+}
+
+.attention-category:hover {
+  border-color: color-mix(in srgb, var(--accent) 55%, var(--line));
+  background: var(--panel-strong);
+}
+
+.attention-category[aria-current="page"] {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+
+.attention-count {
+  font-variant-numeric: tabular-nums;
+}
+
+.attention-category.empty {
+  color: var(--muted);
+}
+
+.attention-note,
+.attention-notice {
+  margin: 0 0 var(--space-4);
+  font-size: var(--text-sm);
+}
+
+.attention-views {
+  display: flex;
+  gap: var(--space-2);
+  margin: 0 0 var(--space-4);
+}
+
+.attention-views button[aria-pressed="true"] {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+
+.attention-rows {
+  display: grid;
+  gap: var(--space-2);
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.attention-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: var(--space-2) var(--space-4);
+  padding: var(--space-3);
+  border: 1px solid var(--line);
+  border-radius: 0.7rem;
+  background: var(--panel-soft);
+}
+
+.attention-row-main {
+  display: grid;
+  gap: var(--space-1);
+  min-width: 0;
+}
+
+.attention-credit {
+  overflow-wrap: anywhere;
+  font-weight: 600;
+}
+
+.attention-fragments {
+  display: flex;
+  flex-wrap: wrap;
+  grid-column: 1;
+  gap: var(--space-2);
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.attention-fragment {
+  display: inline-block;
+  padding: var(--space-1) var(--space-2);
+  border: 1px solid var(--line-strong);
+  border-radius: 999px;
+  font-size: var(--text-sm);
+}
+
+/* A fragment the library already knows is the strongest hint a split is
+   right, so it reads as a link to that artist. */
+.attention-fragment.known {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+
+.attention-actions {
+  display: flex;
+  flex-wrap: wrap;
+  grid-column: 2;
+  grid-row: 1 / span 2;
+  gap: var(--space-2);
+}
+
+@media (max-width: 40rem) {
+  .attention-actions {
+    grid-column: 1;
+    grid-row: auto;
+  }
+}
+
+.artist-split {
+  margin-top: var(--space-2);
+}
+
+.artist-image-button.armed {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+
 /* The artist header's backdrop (RFC-013): the banner chosen by hand, framed at
    a fixed point as the desktop frames it, or else the portrait, blurred. The
    gradient keeps the title legible over any picture, so the text goes light

From aaeb6918b41002827be309a7711799a1c75b377d Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sat, 24 Oct 2026 06:30:55 +0200
Subject: [PATCH 2/4] docs: RFC-015 names #316 in its Implemented by line

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 docs/rfcs/RFC-015-artist-credit-splitting.md | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/docs/rfcs/RFC-015-artist-credit-splitting.md b/docs/rfcs/RFC-015-artist-credit-splitting.md
index 91f956c6..4016b7e1 100644
--- a/docs/rfcs/RFC-015-artist-credit-splitting.md
+++ b/docs/rfcs/RFC-015-artist-credit-splitting.md
@@ -1,10 +1,14 @@
 # RFC-015 — Splitting a joined artist credit, and a page for what needs a decision
 
 - **Status**: Proposed
-- **Implemented by**: in progress, in the order of "The order of the work"
-  below: [#315](https://github.com/InstaZDLL/waveflow-server/pull/315) (this
-  RFC). The *Status* field above never flips in this project; this line is the
-  one that says what is running.
+- **Implemented by**: [#315](https://github.com/InstaZDLL/waveflow-server/pull/315)
+  (this RFC) and [#316](https://github.com/InstaZDLL/waveflow-server/pull/316)
+  (steps 2 to 4 together: the decision table and `track_credit`, the second
+  step in the scan, applying and undoing a decision, favourites and ratings
+  through the journal, the "Needs attention" routes and track categories, the
+  web client's page and the artist page's "Split into N artists"). The
+  *Status* field above never flips in this project; this line is the one that
+  says what is running.
 - **Date**: 2026-10-24
 - **Revised**: 2026-10-24, after review on #315. The server keeps each
   track's credits as the tags give them (`track_credit`), and one function

From 30903d2c270edb3eceb4387c3cf1d56d509bc1fa Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sat, 24 Oct 2026 14:34:19 +0200
Subject: [PATCH 3/4] fix: decisions read once per batch and re-derived in
 their own transaction

Review on #316. A scan batch reads the library's decisions once, inside
its transaction, and every caller of the per-track apply passes them in.
A decision and its undo now run the end-of-scan derivations in the same
transaction that records them, so the two land or fail together. Probable
duplicates are computed off the async workers, the web client reloads
the credits after a refused decision, draws duplicates group by group,
and leaves a split artist's page before invalidating. A test no longer
prints a result that carries identifiers.

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 src/catalog.rs                         | 65 ++++++++++++++++--------
 src/services/attention.rs              | 70 ++++++++++++++------------
 src/services/credit_decisions.rs       | 34 +++++++------
 src/services/track_metadata.rs         |  2 +
 src/services/uploads.rs                |  2 +
 tests/credits.rs                       |  4 +-
 webapp/e2e/studio-nocturne.spec.ts     | 58 ++++++++++++++++++++-
 webapp/src/components/artist-split.tsx |  4 +-
 webapp/src/pages/attention-page.tsx    | 33 ++++++++++--
 webapp/src/state/i18n.tsx              |  2 +
 webapp/src/styles/styles.css           |  5 ++
 11 files changed, 206 insertions(+), 73 deletions(-)

diff --git a/src/catalog.rs b/src/catalog.rs
index e01f4bd6..303edbc6 100644
--- a/src/catalog.rs
+++ b/src/catalog.rs
@@ -712,6 +712,18 @@ impl Database {
     pub async fn consolidate_sort_names(&self, library_id: Uuid) -> Result<(), sqlx::Error> {
         let _writer = self.writer_guard().await;
         let mut tx = self.pool().begin().await?;
+        Self::consolidate_sort_names_in(&mut tx, library_id).await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// [`Self::consolidate_sort_names`] inside a transaction the caller holds,
+    /// under the writer gate it already took: a credit decision re-derives in
+    /// the transaction that records it, so the two land or fail together.
+    pub(crate) async fn consolidate_sort_names_in(
+        tx: &mut Transaction<'_, Sqlite>,
+        library_id: Uuid,
+    ) -> Result<(), sqlx::Error> {
         sqlx::query(
             "UPDATE album SET sort_name = ( \
                SELECT t.sort_album FROM track t \
@@ -723,7 +735,7 @@ impl Database {
              WHERE library_id = ?",
         )
         .bind(library_id.to_string())
-        .execute(&mut *tx)
+        .execute(&mut **tx)
         .await?;
         sqlx::query(
             "UPDATE artist SET sort_name = ( \
@@ -737,9 +749,8 @@ impl Database {
              WHERE library_id = ?",
         )
         .bind(library_id.to_string())
-        .execute(&mut *tx)
+        .execute(&mut **tx)
         .await?;
-        tx.commit().await?;
         Ok(())
     }
 
@@ -761,6 +772,18 @@ impl Database {
     ) -> Result<(), sqlx::Error> {
         let _writer = self.writer_guard().await;
         let mut tx = self.pool().begin().await?;
+        Self::consolidate_catalog_derivations_in(&mut tx, library_id).await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// [`Self::consolidate_catalog_derivations`] inside a transaction the caller
+    /// holds, under the writer gate it already took, for the same reason as
+    /// [`Self::consolidate_sort_names_in`].
+    pub(crate) async fn consolidate_catalog_derivations_in(
+        tx: &mut Transaction<'_, Sqlite>,
+        library_id: Uuid,
+    ) -> Result<(), sqlx::Error> {
         sqlx::query(
             "UPDATE album SET musicbrainz_id = ( \
                SELECT t.musicbrainz_release_id FROM track t \
@@ -775,7 +798,7 @@ impl Database {
              WHERE library_id = ?",
         )
         .bind(library_id.to_string())
-        .execute(&mut *tx)
+        .execute(&mut **tx)
         .await?;
         sqlx::query(
             "UPDATE artist SET musicbrainz_id = ( \
@@ -789,7 +812,7 @@ impl Database {
              WHERE library_id = ?",
         )
         .bind(library_id.to_string())
-        .execute(&mut *tx)
+        .execute(&mut **tx)
         .await?;
         // The album's own credits, derived here rather than written per track.
         // A track-by-track write would be a last-writer-wins race between
@@ -797,7 +820,7 @@ impl Database {
         // settled makes the answer the same whatever order the scan ran in.
         sqlx::query("DELETE FROM album_participant WHERE library_id = ?")
             .bind(library_id.to_string())
-            .execute(&mut *tx)
+            .execute(&mut **tx)
             .await?;
         sqlx::query(
             "INSERT INTO album_participant \
@@ -812,7 +835,7 @@ impl Database {
               GROUP BY t.album_id, tp.artist_id, tp.role, tp.sub_role",
         )
         .bind(library_id.to_string())
-        .execute(&mut *tx)
+        .execute(&mut **tx)
         .await?;
         // What each artist has to show for each capacity. `albumCount` used to
         // be a count over the album's single artist column, which could only
@@ -820,7 +843,7 @@ impl Database {
         // simply the keys of this table.
         sqlx::query("DELETE FROM artist_role_stats WHERE library_id = ?")
             .bind(library_id.to_string())
-            .execute(&mut *tx)
+            .execute(&mut **tx)
             .await?;
         sqlx::query(
             "INSERT INTO artist_role_stats \
@@ -833,7 +856,7 @@ impl Database {
               GROUP BY tp.artist_id, t.library_id, tp.role",
         )
         .bind(library_id.to_string())
-        .execute(&mut *tx)
+        .execute(&mut **tx)
         .await?;
         // An album no track depends on is no longer in the catalogue. This
         // matters most on the scan that follows the identity migration: the
@@ -847,7 +870,7 @@ impl Database {
                AND NOT EXISTS (SELECT 1 FROM track t WHERE t.album_id = album.id)",
         )
         .bind(library_id.to_string())
-        .execute(&mut *tx)
+        .execute(&mut **tx)
         .await?;
         // An artist row outlives the tag that created it: rename a credit and
         // the old name stays in the index forever. An artist credited on
@@ -861,7 +884,7 @@ impl Database {
                AND NOT EXISTS (SELECT 1 FROM album al WHERE al.album_artist_id = artist.id)",
         )
         .bind(library_id.to_string())
-        .execute(&mut *tx)
+        .execute(&mut **tx)
         .await?;
         // The artist search index, rewritten whole rather than kept in step
         // row by row. An artist row is touched once per track of every album
@@ -872,7 +895,7 @@ impl Database {
         // standing, under the sort names settled before this pass ran.
         sqlx::query("DELETE FROM artist_fts WHERE library_id = ?")
             .bind(library_id.to_string())
-            .execute(&mut *tx)
+            .execute(&mut **tx)
             .await?;
         sqlx::query(
             "INSERT INTO artist_fts (artist_id, library_id, name, sort_name) \
@@ -880,9 +903,8 @@ impl Database {
                FROM artist WHERE library_id = ?",
         )
         .bind(library_id.to_string())
-        .execute(&mut *tx)
+        .execute(&mut **tx)
         .await?;
-        tx.commit().await?;
         Ok(())
     }
 
@@ -1122,6 +1144,11 @@ impl Database {
         }
         let _writer = self.writer_guard().await;
         let mut tx = self.pool().begin().await?;
+        // Read once per batch, inside the transaction that writes it (RFC-015):
+        // a decision taken while a scan runs is either before this batch,
+        // which applies it, or after it, in which case the decision's own pass
+        // finds what this batch wrote.
+        let decisions = credit_decisions(&mut tx, library_id).await?;
         let now = now_ms();
         let mut outcomes = Vec::with_capacity(applies.len());
         for apply in applies {
@@ -1132,6 +1159,7 @@ impl Database {
                     library_id,
                     Some(scan_id),
                     apply,
+                    &decisions,
                     now,
                 )
                 .await?,
@@ -1168,6 +1196,7 @@ impl Database {
         library_id: Uuid,
         scan_id: Option<Uuid>,
         apply: &CatalogApply,
+        decisions: &crate::credit_split::Decisions,
         now: i64,
     ) -> Result<ApplyOutcome, sqlx::Error> {
         let input = &apply.input;
@@ -1189,14 +1218,10 @@ impl Database {
         // not undo them. Only its own `artist` credits are displaced: a
         // composer or a conductor comes from the file and nobody corrected it.
         let overrides = track_override_lists(tx, track_id).await?;
-        // Read inside the transaction that writes the batch, so a decision
-        // taken while a scan runs is either before this batch, which applies
-        // it, or after it, in which case the decision's own pass finds what
-        // this batch wrote.
-        let decisions = credit_decisions(tx, library_id).await?;
+        // The library's decisions, read by the caller inside this transaction.
         let credits = crate::credit_split::resolve(
             &file_credits,
-            &decisions,
+            decisions,
             overrides.artists.as_deref(),
             |name| pid.artist_id(library_id, name.trim()),
         );
diff --git a/src/services/attention.rs b/src/services/attention.rs
index 14468d51..f31279f6 100644
--- a/src/services/attention.rs
+++ b/src/services/attention.rs
@@ -314,39 +314,45 @@ impl DomainServices {
         .bind(library_id.to_string())
         .fetch_all(self.db.pool())
         .await?;
-        let mut artists: HashMap<String, Vec<String>> = HashMap::new();
-        for (track, artist) in credited {
-            artists.entry(track).or_default().push(artist);
-        }
-        let mut buckets: BTreeMap<(String, String), Vec<(usize, i64)>> = BTreeMap::new();
-        for (index, (id, title, duration)) in tracks.iter().enumerate() {
-            let mut names = artists.remove(id).unwrap_or_default();
-            names.sort();
-            let key = (
-                waveflow_core::metadata::name_match::normalize_name(title),
-                names.join("|"),
-            );
-            buckets.entry(key).or_default().push((index, *duration));
-        }
-        let mut grouped = Vec::new();
-        let mut group = 0;
-        for items in buckets.into_values() {
-            let items: Vec<(i64, i64)> = items
-                .into_iter()
-                .map(|(index, duration)| (index as i64, duration))
-                .collect();
-            for members in waveflow_core::inventory::chain_by_duration(
-                &items,
-                waveflow_core::inventory::DURATION_TOLERANCE_MS,
-            ) {
-                group += 1;
-                for member in members {
-                    let id = Uuid::parse_str(&tracks[member as usize].0)
-                        .map_err(|_| ServiceError::Invalid)?;
-                    grouped.push((id, group));
+        // Normalising every title and chaining every bucket is work in
+        // proportion to the library, so it runs off the async workers.
+        tokio::task::spawn_blocking(move || {
+            let mut artists: HashMap<String, Vec<String>> = HashMap::new();
+            for (track, artist) in credited {
+                artists.entry(track).or_default().push(artist);
+            }
+            let mut buckets: BTreeMap<(String, String), Vec<(usize, i64)>> = BTreeMap::new();
+            for (index, (id, title, duration)) in tracks.iter().enumerate() {
+                let mut names = artists.remove(id).unwrap_or_default();
+                names.sort();
+                let key = (
+                    waveflow_core::metadata::name_match::normalize_name(title),
+                    names.join("|"),
+                );
+                buckets.entry(key).or_default().push((index, *duration));
+            }
+            let mut grouped = Vec::new();
+            let mut group = 0;
+            for items in buckets.into_values() {
+                let items: Vec<(i64, i64)> = items
+                    .into_iter()
+                    .map(|(index, duration)| (index as i64, duration))
+                    .collect();
+                for members in waveflow_core::inventory::chain_by_duration(
+                    &items,
+                    waveflow_core::inventory::DURATION_TOLERANCE_MS,
+                ) {
+                    group += 1;
+                    for member in members {
+                        let id = Uuid::parse_str(&tracks[member as usize].0)
+                            .map_err(|_| ServiceError::Invalid)?;
+                        grouped.push((id, group));
+                    }
                 }
             }
-        }
-        Ok(grouped)
+            Ok(grouped)
+        })
+        .await
+        .map_err(|_| ServiceError::Unavailable)?
     }
 }
diff --git a/src/services/credit_decisions.rs b/src/services/credit_decisions.rs
index 10e0c17e..820f200a 100644
--- a/src/services/credit_decisions.rs
+++ b/src/services/credit_decisions.rs
@@ -332,14 +332,14 @@ impl DomainServices {
                 .await?;
             }
         }
+        if parts.is_some() {
+            rederive(&mut tx, library_id).await?;
+        }
         tx.commit().await?;
         drop(writer);
         for (user, receipt) in receipts {
             self.sync.publish(user, receipt);
         }
-        if parts.is_some() {
-            self.rederive(library_id).await?;
-        }
         self.credit_decisions(user_id, library_id)
             .await?
             .into_iter()
@@ -441,11 +441,11 @@ impl DomainServices {
                 .await?;
             }
         }
-        tx.commit().await?;
-        drop(writer);
         if split {
-            self.rederive(library_id).await?;
+            rederive(&mut tx, library_id).await?;
         }
+        tx.commit().await?;
+        drop(writer);
         Ok(())
     }
 
@@ -517,15 +517,6 @@ impl DomainServices {
         Ok(())
     }
 
-    /// The derivations a scan reruns at its end, rerun because the credits
-    /// they are derived from moved: album credits, per-role counts, the artist
-    /// sweep and the search index, then the sort names.
-    async fn rederive(&self, library_id: Uuid) -> Result<(), ServiceError> {
-        self.db.consolidate_catalog_derivations(library_id).await?;
-        self.db.consolidate_sort_names(library_id).await?;
-        Ok(())
-    }
-
     /// Carries each account's favourite and rating on an artist the split
     /// removed onto every part, through that account's journal (RFC-015
     /// decision 4), so a desktop mirror sees the same move the server made.
@@ -718,6 +709,19 @@ impl DomainServices {
     }
 }
 
+/// The derivations a scan reruns at its end, rerun because the credits they
+/// are derived from moved: album credits, per-role counts, the artist sweep
+/// and the search index, then the sort names.
+///
+/// In the decision's own transaction, under the writer gate it already holds:
+/// a decision recorded while its derivations failed would leave an artist row
+/// the feed has already announced as deleted, and a retry would only answer
+/// `409`. Together, the two land or neither does.
+async fn rederive(tx: &mut Transaction<'_, Sqlite>, library_id: Uuid) -> Result<(), sqlx::Error> {
+    crate::database::Database::consolidate_catalog_derivations_in(tx, library_id).await?;
+    crate::database::Database::consolidate_sort_names_in(tx, library_id).await
+}
+
 /// Whether anything still credits an artist: a participant, or an album that
 /// hangs off it. What the end-of-scan sweep checks before deleting the row.
 async fn still_credited(
diff --git a/src/services/track_metadata.rs b/src/services/track_metadata.rs
index dfa1a0a2..4f3f2c08 100644
--- a/src/services/track_metadata.rs
+++ b/src/services/track_metadata.rs
@@ -326,6 +326,7 @@ impl DomainServices {
             // have refused every received file until a scan happened to walk
             // past it.
             let scan_id = last_seen_scan_id.map(parse_uuid).transpose()?;
+            let decisions = crate::catalog::credit_decisions(&mut tx, library_id).await?;
             crate::database::Database::apply_catalog_track_in_transaction(
                 &mut tx,
                 self.db.pid(),
@@ -337,6 +338,7 @@ impl DomainServices {
                     moved: false,
                     origin_device_id,
                 },
+                &decisions,
                 now,
             )
             .await?;
diff --git a/src/services/uploads.rs b/src/services/uploads.rs
index c6f2c9f2..3de4630a 100644
--- a/src/services/uploads.rs
+++ b/src/services/uploads.rs
@@ -858,6 +858,7 @@ impl DomainServices {
                 .bind(&relative)
                 .fetch_optional(&mut *tx)
                 .await?;
+        let decisions = crate::catalog::credit_decisions(&mut tx, target.library_id).await?;
         crate::database::Database::apply_catalog_track_in_transaction(
             &mut tx,
             self.db.pid(),
@@ -874,6 +875,7 @@ impl DomainServices {
                 // the feed as a track it has just discovered.
                 origin_device_id,
             },
+            &decisions,
             now,
         )
         .await?;
diff --git a/tests/credits.rs b/tests/credits.rs
index e7566005..4be480b7 100644
--- a/tests/credits.rs
+++ b/tests/credits.rs
@@ -895,12 +895,14 @@ async fn a_second_decision_on_one_credit_is_a_conflict() {
             CreditDecisionKind::Split,
         )
         .await;
+    // Asserted on the variant alone: printing the result would put the
+    // decision's identifiers in the failure message for nothing.
     assert!(
         matches!(
             again,
             Err(waveflow_server::services::ServiceError::Conflict)
         ),
-        "{again:?}"
+        "a second decision on one credit is a conflict"
     );
 }
 
diff --git a/webapp/e2e/studio-nocturne.spec.ts b/webapp/e2e/studio-nocturne.spec.ts
index d7167c03..6bc360c5 100644
--- a/webapp/e2e/studio-nocturne.spec.ts
+++ b/webapp/e2e/studio-nocturne.spec.ts
@@ -5630,6 +5630,9 @@ async function serveAttention(page: Page) {
     decisions: [] as Array<Record<string, unknown>>,
     writes: [] as Array<{ method: string; path: string; body: unknown }>,
     asks: 0,
+    /** Answer the next decision with this status, as if another owner had
+     * decided first: the credit leaves the list on the server. */
+    refuseWith: null as number | null,
   };
   const base = "**/api/v2/libraries/library-1";
   await page.route(`${base}/attention`, (route) => {
@@ -5657,8 +5660,22 @@ async function serveAttention(page: Page) {
     const category = new URL(route.request().url()).searchParams.get(
       "category",
     );
+    const twice = (index: number, title: string, group: number) => ({
+      ...song(index, title, 0, false),
+      duplicate_group: group,
+    });
     return route.fulfill({
-      json: category === "missing_year" ? [song(4, "Yearless", 0, false)] : [],
+      json:
+        category === "missing_year"
+          ? [song(4, "Yearless", 0, false)]
+          : category === "probable_duplicate"
+            ? [
+                twice(5, "Echo", 1),
+                twice(6, "Echo (copy)", 1),
+                twice(7, "Other", 2),
+                twice(8, "Other (copy)", 2),
+              ]
+            : [],
     });
   });
   await page.route(`${base}/credit-decisions`, async (route) => {
@@ -5669,6 +5686,13 @@ async function serveAttention(page: Page) {
     }
     const body = request.postDataJSON();
     state.writes.push({ method: "POST", path: "credit-decisions", body });
+    if (state.refuseWith !== null) {
+      const status = state.refuseWith;
+      state.refuseWith = null;
+      state.candidates = [];
+      await route.fulfill({ status, json: { error: "conflict" } });
+      return;
+    }
     const candidate = state.candidates.find(
       (entry) => entry.artist_id === body.artist_id,
     );
@@ -5768,9 +5792,41 @@ test("lists what needs attention, splits a credit on the second click, and undoe
   await lists.getByRole("link", { name: /Missing year/ }).click();
   await expect(page).toHaveURL(/category=missing_year/);
   await expect(page.getByText("Yearless")).toBeVisible();
+
+  // Probable duplicates are drawn group by group.
+  await lists.getByRole("link", { name: /Probable duplicates/ }).click();
+  await expect(
+    page.getByRole("heading", { name: "Probable duplicate 1" }),
+  ).toBeVisible();
+  await expect(
+    page.getByRole("heading", { name: "Probable duplicate 2" }),
+  ).toBeVisible();
+  await expect(page.locator(".attention-group")).toHaveCount(2);
+  await expect(
+    page.locator(".attention-group").first().getByText("Echo (copy)"),
+  ).toBeVisible();
   await expectNoWcagViolations(page);
 });
 
+/**
+ * Two owners deciding the same credit: the second is refused, and the list is
+ * read again rather than left showing a row that is no longer there.
+ */
+test("reloads the credits when a decision is refused", async ({ page }) => {
+  const state = await serveAttention(page);
+  state.refuseWith = 409;
+  await page.goto("/attention?category=split_credits");
+  await page.getByRole("button", { name: "Keep as one" }).click();
+  await expect(
+    page.getByText(
+      "This credit was decided in the meantime. The list has been reloaded.",
+    ),
+  ).toBeVisible();
+  await expect(
+    page.getByText("No credit is waiting for a decision."),
+  ).toBeVisible();
+});
+
 /**
  * A listener cannot act on any of it, so the page says so and asks nothing:
  * the server would answer `404` regardless.
diff --git a/webapp/src/components/artist-split.tsx b/webapp/src/components/artist-split.tsx
index f9fa0e73..48787c8d 100644
--- a/webapp/src/components/artist-split.tsx
+++ b/webapp/src/components/artist-split.tsx
@@ -37,8 +37,10 @@ export function ArtistSplit({ artist }: { artist: ArtistDetail }) {
     setFailed(false);
     try {
       await decideCredit(artist.library_id, artist.id, "split");
-      await client.invalidateQueries();
+      // Away first: this page's own query would otherwise be asked again,
+      // and answer 404, before the artists list could be reached.
       await navigate({ to: "/artists" });
+      await client.invalidateQueries();
     } catch {
       setFailed(true);
       setBusy(false);
diff --git a/webapp/src/pages/attention-page.tsx b/webapp/src/pages/attention-page.tsx
index 233836c5..b3707919 100644
--- a/webapp/src/pages/attention-page.tsx
+++ b/webapp/src/pages/attention-page.tsx
@@ -9,6 +9,7 @@ import { useEffect, useMemo, useState } from "react";
 import {
   ApiError,
   type AttentionCategory,
+  type AttentionTrack,
   type CreditCandidate,
   type CreditDecision,
   decideCredit,
@@ -180,12 +181,34 @@ function TracksPanel({
   const { t } = useI18n();
   const tracks = useInfiniteQuery(attentionTracksQuery(libraryId, category));
   const songs = useMemo(() => tracks.data?.pages.flat() ?? [], [tracks.data]);
+  // Probable duplicates arrive group by group; each is drawn as its own table
+  // so a group reads as one recording. A group a page boundary cut in two is
+  // joined again here, because adjacent rows of one group are one group.
+  const groups = useMemo(() => {
+    const grouped: Array<{ group: number; songs: AttentionTrack[] }> = [];
+    for (const song of songs) {
+      const group = song.duplicate_group ?? 0;
+      const last = grouped.at(-1);
+      if (last && last.group === group) last.songs.push(song);
+      else grouped.push({ group, songs: [song] });
+    }
+    return grouped;
+  }, [songs]);
   if (!tracks.data) return <Loading error={tracks.error} />;
   if (!songs.length) return <p className="muted">{t("attention.empty")}</p>;
   return (
     <>
       <p className="muted attention-note">{t("attention.tracksNote")}</p>
-      <SongTable songs={songs} />
+      {category === "probable_duplicate" ? (
+        groups.map((entry) => (
+          <section key={entry.group} className="attention-group">
+            <h3>{t("attention.duplicateGroup", { group: entry.group })}</h3>
+            <SongTable songs={entry.songs} />
+          </section>
+        ))
+      ) : (
+        <SongTable songs={songs} />
+      )}
       {tracks.hasNextPage ? (
         <div className="actions">
           <button
@@ -224,20 +247,24 @@ function CreditsPanel({ libraryId }: { libraryId: string }) {
   async function attempt(write: () => Promise<unknown>, said: string) {
     setBusy(true);
     setNotice(null);
+    // Re-read whatever the answer: a refusal is usually another owner having
+    // decided first — the credit is decided, or its artist is gone — and the
+    // row on screen is what is out of date.
     try {
       await write();
-      await client.invalidateQueries();
       setNotice({ error: false, text: said });
     } catch (error) {
       setNotice({
         error: true,
         text: t(
-          error instanceof ApiError && error.status === 409
+          error instanceof ApiError &&
+            (error.status === 409 || error.status === 404)
             ? "attention.alreadyDecided"
             : "attention.failed",
         ),
       });
     } finally {
+      await client.invalidateQueries();
       setBusy(false);
     }
   }
diff --git a/webapp/src/state/i18n.tsx b/webapp/src/state/i18n.tsx
index fac55fe1..9c9b3d0d 100644
--- a/webapp/src/state/i18n.tsx
+++ b/webapp/src/state/i18n.tsx
@@ -476,6 +476,7 @@ const en = {
   "attention.decidedKeep": "Kept as one",
   "attention.decidedBy": "By {who}, {when}",
   "attention.undo": "Undo",
+  "attention.duplicateGroup": "Probable duplicate {group}",
   "attention.split_credits": "Artists to split",
   "attention.missing_artist": "Missing artist",
   "attention.missing_album": "Missing album",
@@ -1240,6 +1241,7 @@ const fr: Record<TranslationKey, TranslationValue> = {
   "attention.decidedKeep": "Gardé tel quel",
   "attention.decidedBy": "Par {who}, le {when}",
   "attention.undo": "Annuler",
+  "attention.duplicateGroup": "Doublon probable {group}",
   "attention.split_credits": "Artistes à scinder",
   "attention.missing_artist": "Sans artiste",
   "attention.missing_album": "Sans album",
diff --git a/webapp/src/styles/styles.css b/webapp/src/styles/styles.css
index a407ac99..8c09f9d3 100644
--- a/webapp/src/styles/styles.css
+++ b/webapp/src/styles/styles.css
@@ -3198,6 +3198,11 @@ button.danger {
   }
 }
 
+.attention-group h3 {
+  margin: var(--space-4) 0 var(--space-2);
+  font-size: var(--text-sm);
+}
+
 .artist-split {
   margin-top: var(--space-2);
 }

From cae97bbfd1395cab1df23d9e3e7ad0f48d4a497e Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sat, 24 Oct 2026 14:50:03 +0200
Subject: [PATCH 4/4] fix: a decision votes the sort names before the search
 index reads them

Review on #316. The end-of-scan derivations run in the scanner's order
when a decision re-derives: sort names first, then the pass that rebuilds
artist_fts from them.

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 src/services/credit_decisions.rs | 10 ++++++----
 tests/credits.rs                 | 24 ++++++++++++++++++++++--
 2 files changed, 28 insertions(+), 6 deletions(-)

diff --git a/src/services/credit_decisions.rs b/src/services/credit_decisions.rs
index 820f200a..7daff5dd 100644
--- a/src/services/credit_decisions.rs
+++ b/src/services/credit_decisions.rs
@@ -710,16 +710,18 @@ impl DomainServices {
 }
 
 /// The derivations a scan reruns at its end, rerun because the credits they
-/// are derived from moved: album credits, per-role counts, the artist sweep
-/// and the search index, then the sort names.
+/// are derived from moved, and in the scan's order: the sort names first,
+/// because the second pass closes by indexing every artist name together with
+/// its sort name; then album credits, per-role counts, the artist sweep and
+/// the search index.
 ///
 /// In the decision's own transaction, under the writer gate it already holds:
 /// a decision recorded while its derivations failed would leave an artist row
 /// the feed has already announced as deleted, and a retry would only answer
 /// `409`. Together, the two land or neither does.
 async fn rederive(tx: &mut Transaction<'_, Sqlite>, library_id: Uuid) -> Result<(), sqlx::Error> {
-    crate::database::Database::consolidate_catalog_derivations_in(tx, library_id).await?;
-    crate::database::Database::consolidate_sort_names_in(tx, library_id).await
+    crate::database::Database::consolidate_sort_names_in(tx, library_id).await?;
+    crate::database::Database::consolidate_catalog_derivations_in(tx, library_id).await
 }
 
 /// Whether anything still credits an artist: a participant, or an album that
diff --git a/tests/credits.rs b/tests/credits.rs
index 4be480b7..f9b3ea60 100644
--- a/tests/credits.rs
+++ b/tests/credits.rs
@@ -117,15 +117,17 @@ impl Shelf {
             .unwrap();
     }
 
+    /// The end of a scan, in the scanner's order: sort names first, because
+    /// the derivations index each artist with its sort name.
     async fn settle(&self) {
         self.state
             .db
-            .consolidate_catalog_derivations(self.library)
+            .consolidate_sort_names(self.library)
             .await
             .unwrap();
         self.state
             .db
-            .consolidate_sort_names(self.library)
+            .consolidate_catalog_derivations(self.library)
             .await
             .unwrap();
     }
@@ -469,6 +471,24 @@ async fn a_split_keeps_each_parts_sort_form() {
             ("C".to_owned(), Some("c".to_owned())),
         ]
     );
+    // And the artists themselves carry them, in the search index as well:
+    // the index is rebuilt from the artist rows, so the sort names have to be
+    // voted before it is, as at the end of a scan.
+    let indexed: Vec<(String, String, String)> = sqlx::query_as(
+        "SELECT ar.name, COALESCE(ar.sort_name, ''), fts.sort_name FROM artist ar          JOIN artist_fts fts ON fts.artist_id = ar.id          WHERE ar.library_id = ? ORDER BY ar.name",
+    )
+    .bind(shelf.library.to_string())
+    .fetch_all(shelf.state.db.pool())
+    .await
+    .unwrap();
+    assert_eq!(
+        indexed,
+        vec![
+            ("A".to_owned(), "a".to_owned(), "a".to_owned()),
+            ("B".to_owned(), "b".to_owned(), "b".to_owned()),
+            ("C".to_owned(), "c".to_owned(), "c".to_owned()),
+        ]
+    );
 }
 
 #[tokio::test]