refactor(download): rename Want/Request to Request/Download, unify downloads flow, add auto-download guardrails

The durable "I asked for this" record was called Want, and the one-shot
search-and-grab attempt was called Request — names that didn't match
what either actually did. Want is now Request, and the old Request/Item
is now Download/DownloadItem, with a table-rename migration
(download_wants -> download_requests, old download_requests ->
download_downloads) safe against both fresh installs and existing data.

Every anchored manual download now upserts/reuses a durable Request
before running, so a "download now" that finds nothing is picked up by
the background reconciler automatically instead of just failing with
no trace — the gap that caused this session's repeated "no candidates
found" failures on the same album.

Also adds auto-download guardrails (file-size min/max with a preferred
target, allowed file types) that gate what the pipeline may grab
unattended, live-editable from a new settings section. The frontend's
wanted-view becomes downloads-view, with a new Downloads tab showing
attempt/transfer history that previously had no UI at all.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y2Agd9af5hE7qzti2ackiS

backend/database/database.go

@@ -306,6 +306,14 @@ func applySchema(ctx context.Context, db *sql.DB) error {
 		return fmt.Errorf("could not apply migrations: %w", err)
 	}
 
+	// The download subsystem's Want/Request rename reuses table names
+	// (download_requests names a different table before and after), so
+	// it cannot be a plain sql/migrations file the way an ADD COLUMN
+	// migration can; see download_rename_migration.go for why.
+	if err := migrateDownloadRename(ctx, db); err != nil {
+		return fmt.Errorf("could not migrate download rename: %w", err)
+	}
+
 	return nil
 }
 

backend/database/download_rename_migration.go

@@ -0,0 +1,141 @@
+package database
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+)
+
+// migrateDownloadRename performs the download subsystem's table rename
+// for existing databases that still carry the old table names: the
+// durable "I asked for this" record moved from download_wants to
+// download_requests, and the one-shot search-and-grab attempt moved
+// from download_requests to download_downloads (see CLAUDE.md and
+// .planning/NOTES.md for the full Want->Request / Request->Download
+// rename).
+//
+// This cannot be a plain sql/migrations file the way an ADD COLUMN
+// migration is. That pattern's tolerance for "duplicate column name"
+// works because a fresh database's sql/schemas pass already produces
+// the identical target shape under the identical table name, so
+// replaying the ALTER TABLE against it is a safe no-op. Here the name
+// "download_requests" is reused for a different table before and after
+// the rename, so a fresh database's schema pass creates a real, empty,
+// correctly-shaped download_downloads AND a real, empty,
+// correctly-shaped (new) download_requests before this ever runs.
+// Blindly replaying "ALTER TABLE download_requests RENAME TO
+// download_downloads" against that fresh database would rename the new,
+// empty Request table into Download's place, destroying the fresh
+// install rather than no-opping. Gating on whether the OLD
+// download_wants table still exists — a name nothing creates or
+// references once this has run — is what tells an old database and a
+// fresh (or already migrated) one apart without executing anything
+// destructive on the fresh path.
+func migrateDownloadRename(ctx context.Context, db *sql.DB) error {
+	var name string
+
+	err := db.QueryRowContext(
+		ctx,
+		`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'download_wants'`,
+	).Scan(&name)
+
+	switch {
+	case errors.Is(err, sql.ErrNoRows):
+		// Nothing to migrate: either a fresh install (sql/schemas
+		// already produced the target shape) or a database this has
+		// already run against.
+	case err != nil:
+		return fmt.Errorf("check for download_wants table: %w", err)
+	default:
+		if err := runDownloadRename(ctx, db); err != nil {
+			return err
+		}
+	}
+
+	return ensureDownloadIndexes(ctx, db)
+}
+
+// runDownloadRename performs the actual rename dance against a
+// database confirmed to still have the old download_wants table.
+func runDownloadRename(ctx context.Context, db *sql.DB) error {
+	stmts := []string{
+		// The schema pass already created an empty, correctly-shaped
+		// download_downloads placeholder under this name (it never
+		// existed under the old naming), which would otherwise collide
+		// with the rename below.
+		`DROP TABLE IF EXISTS download_downloads`,
+
+		// 1. Free the "download_requests" name: the old one-shot
+		// attempt table becomes download_downloads.
+		`ALTER TABLE download_requests RENAME TO download_downloads`,
+		`ALTER TABLE download_downloads RENAME COLUMN want_id TO request_id`,
+
+		// 2. Claim the now-free "download_requests" name for the
+		// durable-intent table.
+		`ALTER TABLE download_wants RENAME TO download_requests`,
+
+		// 3. The transfer table's FK now points at download_downloads.
+		`ALTER TABLE download_items RENAME COLUMN request_id TO download_id`,
+
+		// Named indexes survive a table/column rename attached to their
+		// old name, so drop them here; ensureDownloadIndexes recreates
+		// them under the names sql/schemas' comments describe.
+		`DROP INDEX IF EXISTS idx_download_requests_created`,
+		`DROP INDEX IF EXISTS idx_download_requests_state`,
+		`DROP INDEX IF EXISTS idx_download_wants_due`,
+		`DROP INDEX IF EXISTS idx_download_wants_entity`,
+		`DROP INDEX IF EXISTS idx_download_wants_parent`,
+		`DROP INDEX IF EXISTS idx_download_items_request`,
+	}
+
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return fmt.Errorf("begin download rename migration: %w", err)
+	}
+
+	defer func() { _ = tx.Rollback() }()
+
+	for _, stmt := range stmts {
+		if _, err := tx.ExecContext(ctx, stmt); err != nil {
+			return fmt.Errorf("download rename migration %q: %w", stmt, err)
+		}
+	}
+
+	if err := tx.Commit(); err != nil {
+		return fmt.Errorf("commit download rename migration: %w", err)
+	}
+
+	return nil
+}
+
+// ensureDownloadIndexes creates the indexes sql/schemas deliberately
+// omits inline for the renamed table/columns (see
+// migrateDownloadRename), under their final names. Safe to call
+// unconditionally: IF NOT EXISTS makes it a no-op once created, and by
+// the time this runs every column/table involved is guaranteed to be
+// in its final shape on both a fresh and a migrated database.
+func ensureDownloadIndexes(ctx context.Context, db *sql.DB) error {
+	stmts := []string{
+		`CREATE INDEX IF NOT EXISTS idx_download_downloads_created
+		    ON download_downloads(created_at DESC)`,
+		`CREATE INDEX IF NOT EXISTS idx_download_downloads_state
+		    ON download_downloads(state)`,
+		`CREATE INDEX IF NOT EXISTS idx_download_requests_due
+		    ON download_requests(next_try_at) WHERE state = 'wanted'`,
+		`CREATE INDEX IF NOT EXISTS idx_download_requests_entity
+		    ON download_requests(entity, state)`,
+		`CREATE INDEX IF NOT EXISTS idx_download_requests_parent
+		    ON download_requests(parent_id)`,
+		`CREATE INDEX IF NOT EXISTS idx_download_items_download
+		    ON download_items(download_id)`,
+	}
+
+	for _, stmt := range stmts {
+		if _, err := db.ExecContext(ctx, stmt); err != nil {
+			return fmt.Errorf("ensure download index: %w", err)
+		}
+	}
+
+	return nil
+}

backend/database/download_rename_migration_test.go

@@ -0,0 +1,365 @@
+package database
+
+import (
+	"database/sql"
+	"errors"
+	"testing"
+)
+
+// oldDownloadRequestsDDL, oldDownloadWantsDDL and oldDownloadItemsDDL
+// are frozen snapshots of the download subsystem's tables exactly as
+// they read before the Want/Request rename (see
+// download_rename_migration.go) — i.e. what a real user's existing
+// database looks like today, before upgrading to a build that includes
+// this migration.
+const oldDownloadRequestsDDL = `
+CREATE TABLE IF NOT EXISTS download_requests (
+    id                 TEXT PRIMARY KEY,
+    library_id         INTEGER NOT NULL,
+    source             TEXT    NOT NULL DEFAULT 'manual',
+    want_id            INTEGER REFERENCES download_wants(id) ON DELETE SET NULL,
+    release_mbid       TEXT,
+    release_group_mbid TEXT,
+    recording_mbid     TEXT,
+    artist             TEXT    NOT NULL DEFAULT '',
+    album              TEXT    NOT NULL DEFAULT '',
+    query              TEXT    NOT NULL DEFAULT '',
+    expected           TEXT    NOT NULL DEFAULT '[]',
+    state              TEXT    NOT NULL DEFAULT 'searching'
+        CHECK(state IN ('searching', 'found', 'queued', 'grabbing',
+                        'verifying', 'tagging', 'importing',
+                        'complete', 'cancelled', 'failed')),
+    error              TEXT    NOT NULL DEFAULT '',
+    created_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY(library_id) REFERENCES libraries(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_download_requests_created
+    ON download_requests(created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_download_requests_state
+    ON download_requests(state);
+`
+
+const oldDownloadWantsDDL = `
+CREATE TABLE IF NOT EXISTS download_wants (
+    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+    mbid       TEXT    NOT NULL,
+    entity     TEXT    NOT NULL
+        CHECK(entity IN ('artist', 'release-group', 'release', 'recording')),
+    library_id INTEGER NOT NULL,
+    artist     TEXT    NOT NULL DEFAULT '',
+    title      TEXT    NOT NULL DEFAULT '',
+    scope      TEXT    NOT NULL DEFAULT 'future'
+        CHECK(scope IN ('future', 'all')),
+    secondary  INTEGER NOT NULL DEFAULT 0,
+    state      TEXT    NOT NULL DEFAULT 'wanted'
+        CHECK(state IN ('wanted', 'satisfied', 'paused')),
+    parent_id  INTEGER,
+    attempts     INTEGER  NOT NULL DEFAULT 0,
+    last_error   TEXT     NOT NULL DEFAULT '',
+    last_tried_at DATETIME,
+    next_try_at  DATETIME,
+    external_ids TEXT    NOT NULL DEFAULT '{}',
+    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(mbid, library_id),
+    FOREIGN KEY(library_id) REFERENCES libraries(id) ON DELETE CASCADE,
+    FOREIGN KEY(parent_id) REFERENCES download_wants(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_download_wants_due
+    ON download_wants(next_try_at)
+    WHERE state = 'wanted';
+
+CREATE INDEX IF NOT EXISTS idx_download_wants_entity
+    ON download_wants(entity, state);
+
+CREATE INDEX IF NOT EXISTS idx_download_wants_parent
+    ON download_wants(parent_id);
+`
+
+const oldDownloadItemsDDL = `
+CREATE TABLE IF NOT EXISTS download_items (
+    id           TEXT PRIMARY KEY,
+    request_id   TEXT    NOT NULL,
+    provider_id  INTEGER NOT NULL,
+    transport_id INTEGER,
+    external_id  TEXT    NOT NULL DEFAULT '',
+    candidate    TEXT    NOT NULL DEFAULT '{}',
+    state        TEXT    NOT NULL DEFAULT 'queued'
+        CHECK(state IN ('searching', 'found', 'queued', 'grabbing',
+                        'verifying', 'tagging', 'importing',
+                        'complete', 'cancelled', 'failed')),
+    staging_dir  TEXT    NOT NULL DEFAULT '',
+    bytes_done   INTEGER NOT NULL DEFAULT 0,
+    bytes_total  INTEGER NOT NULL DEFAULT 0,
+    imported_paths TEXT  NOT NULL DEFAULT '[]',
+    error        TEXT    NOT NULL DEFAULT '',
+    created_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY(request_id) REFERENCES download_requests(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_download_items_live
+    ON download_items(state)
+    WHERE state NOT IN ('complete', 'cancelled', 'failed');
+
+CREATE INDEX IF NOT EXISTS idx_download_items_request
+    ON download_items(request_id);
+
+CREATE INDEX IF NOT EXISTS idx_download_items_state
+    ON download_items(state);
+`
+
+// seedOldDownloadSchema builds the pre-rename download tables and
+// inserts one row of real data into each, standing in for a real
+// user's database at the moment it upgrades.
+func seedOldDownloadSchema(t *testing.T, db *sql.DB) {
+	t.Helper()
+
+	for _, ddl := range []string{
+		oldDownloadWantsDDL, oldDownloadRequestsDDL, oldDownloadItemsDDL,
+	} {
+		if _, err := db.ExecContext(t.Context(), ddl); err != nil {
+			t.Fatalf("create old download schema: %v", err)
+		}
+	}
+
+	if _, err := db.ExecContext(
+		t.Context(),
+		`INSERT INTO libraries (id, name, path) VALUES (1, 'Test', '/music')`,
+	); err != nil {
+		t.Fatalf("seed library: %v", err)
+	}
+
+	if _, err := db.ExecContext(
+		t.Context(),
+		`INSERT INTO download_wants
+		    (id, mbid, entity, library_id, artist, title, state)
+		 VALUES (1, 'artist-mbid', 'artist', 1, 'Radiohead', 'Radiohead', 'wanted')`,
+	); err != nil {
+		t.Fatalf("seed download_wants: %v", err)
+	}
+
+	if _, err := db.ExecContext(
+		t.Context(),
+		`INSERT INTO download_requests
+		    (id, library_id, source, want_id, release_group_mbid, artist, album, state)
+		 VALUES ('dl-1', 1, 'wanted', 1, 'rg-mbid', 'Radiohead', 'OK Computer', 'complete')`,
+	); err != nil {
+		t.Fatalf("seed download_requests: %v", err)
+	}
+
+	if _, err := db.ExecContext(
+		t.Context(),
+		`INSERT INTO download_items
+		    (id, request_id, provider_id, state)
+		 VALUES ('item-1', 'dl-1', 1, 'complete')`,
+	); err != nil {
+		t.Fatalf("seed download_items: %v", err)
+	}
+}
+
+// TestDownloadRename_FreshInstallUntouched confirms applySchema on a
+// brand-new database produces the target shape directly and that
+// migrateDownloadRename's gate (checking for the old download_wants
+// table) is a no-op there — the destructive path this test guards
+// against is exactly the one described in download_rename_migration.go:
+// blindly replaying the rename against a fresh database's already-
+// correct, empty download_requests/download_downloads tables.
+func TestDownloadRename_FreshInstallUntouched(t *testing.T) {
+	t.Parallel()
+
+	db := openMemDB(t)
+
+	if err := applySchema(t.Context(), db); err != nil {
+		t.Fatalf("apply schema (fresh): %v", err)
+	}
+
+	for _, table := range []string{"download_downloads", "download_requests", "download_items"} {
+		var name string
+
+		err := db.QueryRowContext(
+			t.Context(),
+			`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`,
+			table,
+		).Scan(&name)
+		if err != nil {
+			t.Errorf("expected table %q to exist on a fresh install: %v", table, err)
+		}
+	}
+
+	var stray string
+
+	err := db.QueryRowContext(
+		t.Context(),
+		`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'download_wants'`,
+	).Scan(&stray)
+	if !errors.Is(err, sql.ErrNoRows) {
+		t.Errorf("old download_wants table should not exist on a fresh install, err=%v", err)
+	}
+
+	// Both auto-download guardrail indexes sql/schemas deliberately
+	// omits (see ensureDownloadIndexes) must still exist.
+	for _, idx := range []string{
+		"idx_download_requests_due",
+		"idx_download_requests_entity",
+		"idx_download_requests_parent",
+		"idx_download_items_download",
+	} {
+		var name string
+
+		err := db.QueryRowContext(
+			t.Context(),
+			`SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?`,
+			idx,
+		).Scan(&name)
+		if err != nil {
+			t.Errorf("expected index %q to exist on a fresh install: %v", idx, err)
+		}
+	}
+}
+
+// TestDownloadRename_UpgradesExistingDatabase is the regression test
+// for the rename itself: an old-shaped database (download_wants +
+// old-style download_requests, both with real rows) must end up with
+// the same table names, column names, and data a fresh install would
+// have — nothing dropped, nothing silently emptied.
+func TestDownloadRename_UpgradesExistingDatabase(t *testing.T) {
+	t.Parallel()
+
+	fresh := openMemDB(t)
+	if err := applySchema(t.Context(), fresh); err != nil {
+		t.Fatalf("apply schema (fresh): %v", err)
+	}
+
+	upgraded := openMemDB(t)
+
+	librariesDDL, err := schemas.ReadFile("sql/schemas/libraries.sql")
+	if err != nil {
+		t.Fatalf("read libraries schema: %v", err)
+	}
+
+	if _, err := upgraded.ExecContext(t.Context(), string(librariesDDL)); err != nil {
+		t.Fatalf("create libraries table: %v", err)
+	}
+
+	seedOldDownloadSchema(t, upgraded)
+
+	if err := applySchema(t.Context(), upgraded); err != nil {
+		t.Fatalf("apply schema (upgrade path): %v", err)
+	}
+
+	// Column order must match a fresh install's, for the same reason
+	// TestMigrations_ColumnOrderMatchesFreshInstall checks tagging_items:
+	// sqlc's `SELECT *` binds positionally.
+	for _, table := range []string{"download_downloads", "download_requests", "download_items"} {
+		freshCols := tableColumns(t, fresh, table)
+		upgradedCols := tableColumns(t, upgraded, table)
+
+		if len(freshCols) != len(upgradedCols) {
+			t.Fatalf(
+				"%s: column count mismatch: fresh has %d (%v), upgraded has %d (%v)",
+				table, len(freshCols), freshCols, len(upgradedCols), upgradedCols,
+			)
+		}
+
+		for i := range freshCols {
+			if freshCols[i] != upgradedCols[i] {
+				t.Errorf(
+					"%s: column order mismatch at %d: fresh %q, upgraded %q\nfresh:    %v\nupgraded: %v",
+					table,
+					i,
+					freshCols[i],
+					upgradedCols[i],
+					freshCols,
+					upgradedCols,
+				)
+			}
+		}
+	}
+
+	// The seeded rows survived the rename under their new names.
+	var (
+		requestMBID   string
+		requestEntity string
+	)
+
+	err = upgraded.QueryRowContext(
+		t.Context(), `SELECT mbid, entity FROM download_requests WHERE id = 1`,
+	).Scan(&requestMBID, &requestEntity)
+	if err != nil {
+		t.Fatalf("seeded request row missing after rename: %v", err)
+	}
+
+	if requestMBID != "artist-mbid" || requestEntity != "artist" {
+		t.Errorf("request row corrupted: mbid=%q entity=%q", requestMBID, requestEntity)
+	}
+
+	var (
+		downloadRequestID sql.NullInt64
+		downloadAlbum     string
+	)
+
+	err = upgraded.QueryRowContext(
+		t.Context(),
+		`SELECT request_id, album FROM download_downloads WHERE id = 'dl-1'`,
+	).Scan(&downloadRequestID, &downloadAlbum)
+	if err != nil {
+		t.Fatalf("seeded download row missing after rename: %v", err)
+	}
+
+	if !downloadRequestID.Valid || downloadRequestID.Int64 != 1 {
+		t.Errorf("download.request_id = %v, want 1 (renamed from want_id)", downloadRequestID)
+	}
+
+	if downloadAlbum != "OK Computer" {
+		t.Errorf("download.album = %q, want OK Computer", downloadAlbum)
+	}
+
+	var itemDownloadID string
+
+	err = upgraded.QueryRowContext(
+		t.Context(),
+		`SELECT download_id FROM download_items WHERE id = 'item-1'`,
+	).Scan(&itemDownloadID)
+	if err != nil {
+		t.Fatalf("seeded item row missing after rename: %v", err)
+	}
+
+	if itemDownloadID != "dl-1" {
+		t.Errorf("item.download_id = %q, want dl-1 (renamed from request_id)", itemDownloadID)
+	}
+
+	// The old table is gone, not just emptied.
+	var stray string
+
+	err = upgraded.QueryRowContext(
+		t.Context(),
+		`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'download_wants'`,
+	).Scan(&stray)
+	if !errors.Is(err, sql.ErrNoRows) {
+		t.Errorf("old download_wants table should be gone after migration, err=%v", err)
+	}
+
+	// Running the whole thing again (as a second app startup would) is
+	// a no-op: the gate sees no download_wants table and does nothing
+	// further, so this must not error or duplicate anything.
+	if err := applySchema(t.Context(), upgraded); err != nil {
+		t.Fatalf("apply schema a second time: %v", err)
+	}
+
+	var count int
+
+	if err := upgraded.QueryRowContext(
+		t.Context(), `SELECT COUNT(*) FROM download_requests`,
+	).Scan(&count); err != nil {
+		t.Fatalf("count download_requests: %v", err)
+	}
+
+	if count != 1 {
+		t.Errorf("download_requests has %d rows after a second migration pass, want 1", count)
+	}
+}

backend/database/sql/queries/download.sql

@@ -22,69 +22,81 @@ WHERE id = ?;
 DELETE FROM download_providers
 WHERE id = ?;
 
--- name: CreateDownloadRequest :exec
-INSERT INTO download_requests (
-    id, library_id, source, want_id, release_mbid, release_group_mbid,
+-- ---------------------------------------------------------------------
+-- Downloads (one-shot search+grab attempts)
+-- ---------------------------------------------------------------------
+
+-- name: CreateDownload :exec
+INSERT INTO download_downloads (
+    id, library_id, source, request_id, release_mbid, release_group_mbid,
     recording_mbid, artist, album, query, expected, state
 )
 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
 
--- name: GetDownloadRequest :one
-SELECT id, library_id, source, want_id, release_mbid, release_group_mbid,
+-- name: GetDownload :one
+SELECT id, library_id, source, request_id, release_mbid, release_group_mbid,
        recording_mbid, artist, album, query, expected, state, error,
        created_at, updated_at
-FROM download_requests
+FROM download_downloads
 WHERE id = ?;
 
--- name: ListDownloadRequests :many
-SELECT id, library_id, source, want_id, release_mbid, release_group_mbid,
+-- name: ListDownloads :many
+SELECT id, library_id, source, request_id, release_mbid, release_group_mbid,
        recording_mbid, artist, album, query, expected, state, error,
        created_at, updated_at
-FROM download_requests
+FROM download_downloads
 ORDER BY created_at DESC
 LIMIT ?;
 
--- name: ListLiveDownloadRequests :many
-SELECT id, library_id, source, want_id, release_mbid, release_group_mbid,
+-- name: ListLiveDownloads :many
+SELECT id, library_id, source, request_id, release_mbid, release_group_mbid,
        recording_mbid, artist, album, query, expected, state, error,
        created_at, updated_at
-FROM download_requests
+FROM download_downloads
 WHERE state NOT IN ('complete', 'cancelled', 'failed')
 ORDER BY created_at;
 
--- name: SetDownloadRequestState :exec
-UPDATE download_requests
+-- name: SetDownloadState :exec
+UPDATE download_downloads
 SET state = ?, error = ?, updated_at = CURRENT_TIMESTAMP
 WHERE id = ?;
 
--- name: DeleteDownloadRequest :exec
-DELETE FROM download_requests
+-- name: DeleteDownload :exec
+DELETE FROM download_downloads
 WHERE id = ?;
 
+-- name: DeleteFinishedDownloads :exec
+DELETE FROM download_downloads
+WHERE state IN ('complete', 'cancelled', 'failed');
+
+-- ---------------------------------------------------------------------
+-- Items (transfer records within a download)
+-- ---------------------------------------------------------------------
+
 -- name: CreateDownloadItem :exec
 INSERT INTO download_items (
-    id, request_id, provider_id, transport_id, external_id,
+    id, download_id, provider_id, transport_id, external_id,
     candidate, state, staging_dir, bytes_total
 )
 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);
 
 -- name: GetDownloadItem :one
-SELECT id, request_id, provider_id, transport_id, external_id, candidate,
+SELECT id, download_id, provider_id, transport_id, external_id, candidate,
        state, staging_dir, bytes_done, bytes_total, imported_paths,
        error, created_at, updated_at
 FROM download_items
 WHERE id = ?;
 
--- name: ListDownloadItemsForRequest :many
-SELECT id, request_id, provider_id, transport_id, external_id, candidate,
+-- name: ListDownloadItemsForDownload :many
+SELECT id, download_id, provider_id, transport_id, external_id, candidate,
        state, staging_dir, bytes_done, bytes_total, imported_paths,
        error, created_at, updated_at
 FROM download_items
-WHERE request_id = ?
+WHERE download_id = ?
 ORDER BY created_at;
 
 -- name: ListLiveDownloadItems :many
-SELECT id, request_id, provider_id, transport_id, external_id, candidate,
+SELECT id, download_id, provider_id, transport_id, external_id, candidate,
        state, staging_dir, bytes_done, bytes_total, imported_paths,
        error, created_at, updated_at
 FROM download_items
@@ -112,72 +124,68 @@ SET imported_paths = ?, state = 'complete', error = '',
     updated_at = CURRENT_TIMESTAMP
 WHERE id = ?;
 
--- name: DeleteFinishedDownloadRequests :exec
-DELETE FROM download_requests
-WHERE state IN ('complete', 'cancelled', 'failed');
-
 -- ---------------------------------------------------------------------
--- Wants
+-- Requests (durable "I asked for this" records)
 -- ---------------------------------------------------------------------
 
--- name: UpsertDownloadWant :one
--- Adding something already wanted is not an error and must not reset
--- the retry clock, so the conflict path only refreshes display text and
--- un-pauses nothing.  scope and secondary are updated because asking
--- again with a wider scope is a real change of intent.
-INSERT INTO download_wants (
+-- name: UpsertDownloadRequest :one
+-- Adding something already requested is not an error and must not
+-- reset the retry clock, so the conflict path only refreshes display
+-- text and un-pauses nothing.  scope and secondary are updated because
+-- asking again with a wider scope is a real change of intent.
+INSERT INTO download_requests (
     mbid, entity, library_id, artist, title, scope, secondary,
     parent_id, next_try_at
 )
 VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
 ON CONFLICT(mbid, library_id) DO UPDATE SET
     artist     = CASE WHEN excluded.artist <> '' THEN excluded.artist
-                      ELSE download_wants.artist END,
+                      ELSE download_requests.artist END,
     title      = CASE WHEN excluded.title <> '' THEN excluded.title
-                      ELSE download_wants.title END,
+                      ELSE download_requests.title END,
     scope      = excluded.scope,
     secondary  = excluded.secondary,
     updated_at = CURRENT_TIMESTAMP
 RETURNING id;
 
--- name: GetDownloadWant :one
-SELECT * FROM download_wants WHERE id = ?;
+-- name: GetDownloadRequest :one
+SELECT * FROM download_requests WHERE id = ?;
 
--- name: GetDownloadWantByMBID :one
-SELECT * FROM download_wants WHERE mbid = ? AND library_id = ?;
+-- name: GetDownloadRequestByMBID :one
+SELECT * FROM download_requests WHERE mbid = ? AND library_id = ?;
 
--- name: ListDownloadWants :many
-SELECT * FROM download_wants
+-- name: ListDownloadRequests :many
+SELECT * FROM download_requests
 ORDER BY
     CASE state WHEN 'wanted' THEN 0 WHEN 'paused' THEN 1 ELSE 2 END,
     artist, title;
 
--- name: ListDownloadWantsByEntity :many
-SELECT * FROM download_wants
+-- name: ListDownloadRequestsByEntity :many
+SELECT * FROM download_requests
 WHERE entity = ? AND state = ?
 ORDER BY id;
 
--- name: ListDueDownloadWants :many
+-- name: ListDueDownloadRequests :many
 -- Everything the reconciler should act on this pass: wanted, not an
 -- artist subscription (those expand rather than download), and either
 -- never tried or past its backoff.
-SELECT * FROM download_wants
+SELECT * FROM download_requests
 WHERE state = 'wanted'
   AND entity <> 'artist'
   AND (next_try_at IS NULL OR next_try_at <= CURRENT_TIMESTAMP)
 ORDER BY attempts, created_at
 LIMIT ?;
 
--- name: ListChildDownloadWants :many
-SELECT * FROM download_wants WHERE parent_id = ? ORDER BY id;
+-- name: ListChildDownloadRequests :many
+SELECT * FROM download_requests WHERE parent_id = ? ORDER BY id;
 
--- name: SetDownloadWantState :exec
-UPDATE download_wants
+-- name: SetDownloadRequestState :exec
+UPDATE download_requests
 SET state = ?, last_error = ?, updated_at = CURRENT_TIMESTAMP
 WHERE id = ?;
 
--- name: RecordDownloadWantAttempt :exec
-UPDATE download_wants
+-- name: RecordDownloadRequestAttempt :exec
+UPDATE download_requests
 SET attempts      = attempts + 1,
     last_error    = ?,
     last_tried_at = CURRENT_TIMESTAMP,
@@ -185,19 +193,19 @@ SET attempts      = attempts + 1,
     updated_at    = CURRENT_TIMESTAMP
 WHERE id = ?;
 
--- name: SatisfyDownloadWant :exec
-UPDATE download_wants
+-- name: SatisfyDownloadRequest :exec
+UPDATE download_requests
 SET state = 'satisfied', last_error = '', next_try_at = NULL,
     updated_at = CURRENT_TIMESTAMP
 WHERE id = ?;
 
--- name: SetDownloadWantExternalIDs :exec
-UPDATE download_wants
+-- name: SetDownloadRequestExternalIDs :exec
+UPDATE download_requests
 SET external_ids = ?, updated_at = CURRENT_TIMESTAMP
 WHERE id = ?;
 
--- name: DeleteDownloadWant :exec
-DELETE FROM download_wants WHERE id = ?;
+-- name: DeleteDownloadRequest :exec
+DELETE FROM download_requests WHERE id = ?;
 
--- name: DeleteSatisfiedDownloadWants :exec
-DELETE FROM download_wants WHERE state = 'satisfied';
+-- name: DeleteSatisfiedDownloadRequests :exec
+DELETE FROM download_requests WHERE state = 'satisfied';

backend/database/sql/schemas/download_downloads.sql

@@ -0,0 +1,53 @@
+-- One row per "go find me this", from the moment a search is fired
+-- until the files are in the library or the attempt is abandoned.  A
+-- Download is one attempt: it searches, it grabs, it succeeds or
+-- fails, and then it is history.  See download_requests.sql for the
+-- durable record a Download may be attached to.
+--
+-- release_mbid / release_group_mbid are the anchor: a download that
+-- carries one can be matched against a known tracklist at import time,
+-- which is what makes unattended completion safe.  Free-text downloads
+-- (both NULL) are always presented to the user for confirmation.
+--
+-- `expected` caches the anchor's tracklist as JSON so ranking and
+-- import do not have to re-resolve it, and so a download survives the
+-- explore index being rebuilt underneath it.
+
+
+CREATE TABLE IF NOT EXISTS download_downloads (
+    id                 TEXT PRIMARY KEY,
+    library_id         INTEGER NOT NULL,
+    -- source records where the download came from: 'explore-album',
+    -- 'explore-artist', 'missing-album', 'wanted', 'manual'.
+    source             TEXT    NOT NULL DEFAULT 'manual',
+    -- request_id is set when this download is attached to a durable
+    -- Request (see download_requests.sql), whether raised by the
+    -- reconciler or attached to a manual anchored download.  NULL for
+    -- a free-text download with nothing stable to attach to.
+    -- Requests are durable and downloads are disposable, so the delete
+    -- is a SET NULL rather than a cascade in either direction.
+    request_id         INTEGER REFERENCES download_requests(id) ON DELETE SET NULL,
+    release_mbid       TEXT,
+    release_group_mbid TEXT,
+    -- recording_mbid anchors a single-track download raised from a
+    -- track-level request.
+    recording_mbid     TEXT,
+    artist             TEXT    NOT NULL DEFAULT '',
+    album              TEXT    NOT NULL DEFAULT '',
+    query              TEXT    NOT NULL DEFAULT '',
+    expected           TEXT    NOT NULL DEFAULT '[]',
+    state              TEXT    NOT NULL DEFAULT 'searching'
+        CHECK(state IN ('searching', 'found', 'queued', 'grabbing',
+                        'verifying', 'tagging', 'importing',
+                        'complete', 'cancelled', 'failed')),
+    error              TEXT    NOT NULL DEFAULT '',
+    created_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY(library_id) REFERENCES libraries(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_download_downloads_created
+    ON download_downloads(created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_download_downloads_state
+    ON download_downloads(state);

backend/database/sql/schemas/download_items.sql

@@ -1,4 +1,4 @@
--- One row per grab attempt against one candidate.  A request can have
+-- One row per grab attempt against one candidate.  A download can have
 -- several: the first pick stalls, the user picks another, or a
 -- search-only provider's candidate is fetched by a separate transport
 -- (in which case provider_id is the searcher and transport_id is the
@@ -17,7 +17,7 @@
 
 CREATE TABLE IF NOT EXISTS download_items (
     id           TEXT PRIMARY KEY,
-    request_id   TEXT    NOT NULL,
+    download_id  TEXT    NOT NULL,
     provider_id  INTEGER NOT NULL,
     transport_id INTEGER,
     external_id  TEXT    NOT NULL DEFAULT '',
@@ -35,15 +35,18 @@ CREATE TABLE IF NOT EXISTS download_items (
     error        TEXT    NOT NULL DEFAULT '',
     created_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    FOREIGN KEY(request_id) REFERENCES download_requests(id) ON DELETE CASCADE
+    FOREIGN KEY(download_id) REFERENCES download_downloads(id) ON DELETE CASCADE
 );
 
 CREATE INDEX IF NOT EXISTS idx_download_items_live
     ON download_items(state)
     WHERE state NOT IN ('complete', 'cancelled', 'failed');
 
-CREATE INDEX IF NOT EXISTS idx_download_items_request
-    ON download_items(request_id);
-
 CREATE INDEX IF NOT EXISTS idx_download_items_state
     ON download_items(state);
+
+-- idx_download_items_download is deliberately NOT declared here: on an
+-- existing database this table already exists at schema-pass time with
+-- its old column still named request_id, so an inline CREATE INDEX on
+-- download_id would fail outright. See ensureDownloadIndexes in
+-- backend/database/download_rename_migration.go.

backend/database/sql/schemas/download_requests.sql

@@ -1,49 +1,79 @@
--- One row per "go find me this", from the moment the user asks until
--- the files are in the library or the attempt is abandoned.
+-- A Request is a persistent "I want this", stored as a MusicBrainz ID
+-- and almost nothing else.  It outlives every download attempt made on
+-- its behalf: nothing being findable today is the normal case for
+-- obscure music, and the correct response is to try again next week,
+-- not to show the user a failed row they have to remember to retry.
 --
--- release_mbid / release_group_mbid are the anchor: a request that
--- carries one can be matched against a known tracklist at import time,
--- which is what makes unattended completion safe.  Free-text requests
--- (both NULL) are always presented to the user for confirmation.
---
--- `expected` caches the anchor's tracklist as JSON so ranking and
--- import do not have to re-resolve it, and so a request survives the
--- explore index being rebuilt underneath it.
+-- Because a Request is only an MBID, it stays true when everything
+-- around it changes: the explore index is rebuilt, a provider is
+-- swapped out, the release the user originally saw is superseded by a
+-- remaster.  The display fields are a cache for the list view and are
+-- never consulted for matching.
 
 
 CREATE TABLE IF NOT EXISTS download_requests (
-    id                 TEXT PRIMARY KEY,
-    library_id         INTEGER NOT NULL,
-    -- source records where the request came from: 'explore-album',
-    -- 'explore-artist', 'missing-album', 'wanted', 'manual'.
-    source             TEXT    NOT NULL DEFAULT 'manual',
-    -- want_id is set when the reconciler raised this request from the
-    -- wanted list, so the outcome can be written back to the want.
-    -- NULL for one-off requests the user started by hand.  Requests are
-    -- disposable and wants are not, so the delete is a SET NULL rather
-    -- than a cascade in either direction.
-    want_id            INTEGER REFERENCES download_wants(id) ON DELETE SET NULL,
-    release_mbid       TEXT,
-    release_group_mbid TEXT,
-    -- recording_mbid anchors a single-track request raised from a
-    -- track-level want.
-    recording_mbid     TEXT,
-    artist             TEXT    NOT NULL DEFAULT '',
-    album              TEXT    NOT NULL DEFAULT '',
-    query              TEXT    NOT NULL DEFAULT '',
-    expected           TEXT    NOT NULL DEFAULT '[]',
-    state              TEXT    NOT NULL DEFAULT 'searching'
-        CHECK(state IN ('searching', 'found', 'queued', 'grabbing',
-                        'verifying', 'tagging', 'importing',
-                        'complete', 'cancelled', 'failed')),
-    error              TEXT    NOT NULL DEFAULT '',
-    created_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    FOREIGN KEY(library_id) REFERENCES libraries(id) ON DELETE CASCADE
+    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+    mbid       TEXT    NOT NULL,
+    entity     TEXT    NOT NULL
+        CHECK(entity IN ('artist', 'release-group', 'release', 'recording')),
+    library_id INTEGER NOT NULL,
+
+    -- Display text, cached so the list renders without touching the
+    -- explore index.  Neither is authoritative; the MBID is.
+    artist     TEXT    NOT NULL DEFAULT '',
+    title      TEXT    NOT NULL DEFAULT '',
+
+    scope      TEXT    NOT NULL DEFAULT 'future'
+        CHECK(scope IN ('future', 'all')),
+
+    -- secondary controls whether an artist request's expansion includes
+    -- compilations, live albums and remixes.  Off by default: someone
+    -- subscribing to an artist wants the albums, not six versions of
+    -- the same greatest-hits package.
+    secondary  INTEGER NOT NULL DEFAULT 0,
+
+    state      TEXT    NOT NULL DEFAULT 'wanted'
+        CHECK(state IN ('wanted', 'satisfied', 'paused')),
+
+    -- parent_id links a request the reconciler derived from an artist
+    -- request.  Deleting the artist takes its derived children with
+    -- it, but children the user pinned themselves have no parent and
+    -- stay.
+    parent_id  INTEGER,
+
+    -- Retry bookkeeping.  attempts drives the backoff; last_error is
+    -- the most recent reason it did not work out, which for a request
+    -- is information rather than a failure.
+    attempts     INTEGER  NOT NULL DEFAULT 0,
+    last_error   TEXT     NOT NULL DEFAULT '',
+    last_tried_at DATETIME,
+    next_try_at  DATETIME,
+
+    -- external_ids maps provider row ID to that provider's own
+    -- identifier for this request, for clients that keep their own
+    -- persistent list (a Lidarr artist ID).  JSON object.
+    external_ids TEXT    NOT NULL DEFAULT '{}',
+
+    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    -- One request per thing per library.  Asking twice is not two
+    -- requests, and this is what lets an artist expansion re-run every
+    -- reconcile without accumulating duplicates.
+    UNIQUE(mbid, library_id),
+
+    FOREIGN KEY(library_id) REFERENCES libraries(id) ON DELETE CASCADE,
+    FOREIGN KEY(parent_id) REFERENCES download_requests(id) ON DELETE CASCADE
 );
 
-CREATE INDEX IF NOT EXISTS idx_download_requests_created
-    ON download_requests(created_at DESC);
-
-CREATE INDEX IF NOT EXISTS idx_download_requests_state
-    ON download_requests(state);
+-- idx_download_requests_{due,entity,parent} are deliberately NOT
+-- declared here. This table name is reused from the old one-shot
+-- attempt table (also called download_requests before the Want/Request
+-- rename), so on an existing database this CREATE TABLE is a no-op
+-- against a table that, at schema-pass time, is still shaped like the
+-- OLD attempts table and lacks these columns entirely — an inline
+-- CREATE INDEX here would fail outright rather than just no-op. See
+-- migrateDownloadRename/ensureDownloadIndexes in
+-- backend/database/download_rename_migration.go, which create these
+-- once the rename has actually happened (or immediately, on a fresh
+-- database where the columns exist from the start).

backend/database/sql/schemas/download_wants.sql

@@ -1,76 +0,0 @@
--- One row per "go find me this", from the moment the user asks until
--- the files are in the library or the attempt is abandoned.
---
--- release_mbid / release_group_mbid are the anchor: a request that
--- carries one can be matched against a known tracklist at import time,
--- which is what makes unattended completion safe.  Free-text requests
--- (both NULL) are always presented to the user for confirmation.
---
--- `expected` caches the anchor's tracklist as JSON so ranking and
--- import do not have to re-resolve it, and so a request survives the
--- explore index being rebuilt underneath it.
-
-
-CREATE TABLE IF NOT EXISTS download_wants (
-    id         INTEGER PRIMARY KEY AUTOINCREMENT,
-    mbid       TEXT    NOT NULL,
-    entity     TEXT    NOT NULL
-        CHECK(entity IN ('artist', 'release-group', 'release', 'recording')),
-    library_id INTEGER NOT NULL,
-
-    -- Display text, cached so the wanted list renders without touching
-    -- the explore index.  Neither is authoritative; the MBID is.
-    artist     TEXT    NOT NULL DEFAULT '',
-    title      TEXT    NOT NULL DEFAULT '',
-
-    scope      TEXT    NOT NULL DEFAULT 'future'
-        CHECK(scope IN ('future', 'all')),
-
-    -- secondary controls whether an artist want's expansion includes
-    -- compilations, live albums and remixes.  Off by default: someone
-    -- subscribing to an artist wants the albums, not six versions of
-    -- the same greatest-hits package.
-    secondary  INTEGER NOT NULL DEFAULT 0,
-
-    state      TEXT    NOT NULL DEFAULT 'wanted'
-        CHECK(state IN ('wanted', 'satisfied', 'paused')),
-
-    -- parent_id links a want the reconciler derived from an artist
-    -- want.  Deleting the artist takes its derived children with it,
-    -- but children the user pinned themselves have no parent and stay.
-    parent_id  INTEGER,
-
-    -- Retry bookkeeping.  attempts drives the backoff; last_error is
-    -- the most recent reason it did not work out, which for a wanted
-    -- item is information rather than a failure.
-    attempts     INTEGER  NOT NULL DEFAULT 0,
-    last_error   TEXT     NOT NULL DEFAULT '',
-    last_tried_at DATETIME,
-    next_try_at  DATETIME,
-
-    -- external_ids maps provider row ID to that provider's own
-    -- identifier for this want, for clients that keep their own
-    -- persistent list (a Lidarr artist ID).  JSON object.
-    external_ids TEXT    NOT NULL DEFAULT '{}',
-
-    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-
-    -- One want per thing per library.  Asking twice is not two wants,
-    -- and this is what lets an artist expansion re-run every reconcile
-    -- without accumulating duplicates.
-    UNIQUE(mbid, library_id),
-
-    FOREIGN KEY(library_id) REFERENCES libraries(id) ON DELETE CASCADE,
-    FOREIGN KEY(parent_id) REFERENCES download_wants(id) ON DELETE CASCADE
-);
-
-CREATE INDEX IF NOT EXISTS idx_download_wants_due
-    ON download_wants(next_try_at)
-    WHERE state = 'wanted';
-
-CREATE INDEX IF NOT EXISTS idx_download_wants_entity
-    ON download_wants(entity, state);
-
-CREATE INDEX IF NOT EXISTS idx_download_wants_parent
-    ON download_wants(parent_id);

backend/database/sql/sqlcgen/download.sql.go

@@ -10,9 +10,55 @@ import (
 	"database/sql"
 )
 
+const createDownload = `-- name: CreateDownload :exec
+
+INSERT INTO download_downloads (
+    id, library_id, source, request_id, release_mbid, release_group_mbid,
+    recording_mbid, artist, album, query, expected, state
+)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`
+
+type CreateDownloadParams struct {
+	ID               string
+	LibraryID        int64
+	Source           string
+	RequestID        sql.NullInt64
+	ReleaseMbid      sql.NullString
+	ReleaseGroupMbid sql.NullString
+	RecordingMbid    sql.NullString
+	Artist           string
+	Album            string
+	Query            string
+	Expected         string
+	State            string
+}
+
+// ---------------------------------------------------------------------
+// Downloads (one-shot search+grab attempts)
+// ---------------------------------------------------------------------
+func (q *Queries) CreateDownload(ctx context.Context, arg CreateDownloadParams) error {
+	_, err := q.db.ExecContext(ctx, createDownload,
+		arg.ID,
+		arg.LibraryID,
+		arg.Source,
+		arg.RequestID,
+		arg.ReleaseMbid,
+		arg.ReleaseGroupMbid,
+		arg.RecordingMbid,
+		arg.Artist,
+		arg.Album,
+		arg.Query,
+		arg.Expected,
+		arg.State,
+	)
+	return err
+}
+
 const createDownloadItem = `-- name: CreateDownloadItem :exec
+
 INSERT INTO download_items (
-    id, request_id, provider_id, transport_id, external_id,
+    id, download_id, provider_id, transport_id, external_id,
     candidate, state, staging_dir, bytes_total
 )
 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -20,7 +66,7 @@ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
 
 type CreateDownloadItemParams struct {
 	ID          string
-	RequestID   string
+	DownloadID  string
 	ProviderID  int64
 	TransportID sql.NullInt64
 	ExternalID  string
@@ -30,10 +76,13 @@ type CreateDownloadItemParams struct {
 	BytesTotal  int64
 }
 
+// ---------------------------------------------------------------------
+// Items (transfer records within a download)
+// ---------------------------------------------------------------------
 func (q *Queries) CreateDownloadItem(ctx context.Context, arg CreateDownloadItemParams) error {
 	_, err := q.db.ExecContext(ctx, createDownloadItem,
 		arg.ID,
-		arg.RequestID,
+		arg.DownloadID,
 		arg.ProviderID,
 		arg.TransportID,
 		arg.ExternalID,
@@ -72,44 +121,13 @@ func (q *Queries) CreateDownloadProvider(ctx context.Context, arg CreateDownload
 	return id, err
 }
 
-const createDownloadRequest = `-- name: CreateDownloadRequest :exec
-INSERT INTO download_requests (
-    id, library_id, source, want_id, release_mbid, release_group_mbid,
-    recording_mbid, artist, album, query, expected, state
-)
-VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+const deleteDownload = `-- name: DeleteDownload :exec
+DELETE FROM download_downloads
+WHERE id = ?
 `
 
-type CreateDownloadRequestParams struct {
-	ID               string
-	LibraryID        int64
-	Source           string
-	WantID           sql.NullInt64
-	ReleaseMbid      sql.NullString
-	ReleaseGroupMbid sql.NullString
-	RecordingMbid    sql.NullString
-	Artist           string
-	Album            string
-	Query            string
-	Expected         string
-	State            string
-}
-
-func (q *Queries) CreateDownloadRequest(ctx context.Context, arg CreateDownloadRequestParams) error {
-	_, err := q.db.ExecContext(ctx, createDownloadRequest,
-		arg.ID,
-		arg.LibraryID,
-		arg.Source,
-		arg.WantID,
-		arg.ReleaseMbid,
-		arg.ReleaseGroupMbid,
-		arg.RecordingMbid,
-		arg.Artist,
-		arg.Album,
-		arg.Query,
-		arg.Expected,
-		arg.State,
-	)
+func (q *Queries) DeleteDownload(ctx context.Context, id string) error {
+	_, err := q.db.ExecContext(ctx, deleteDownload, id)
 	return err
 }
 
@@ -124,45 +142,66 @@ func (q *Queries) DeleteDownloadProvider(ctx context.Context, id int64) error {
 }
 
 const deleteDownloadRequest = `-- name: DeleteDownloadRequest :exec
-DELETE FROM download_requests
-WHERE id = ?
+DELETE FROM download_requests WHERE id = ?
 `
 
-func (q *Queries) DeleteDownloadRequest(ctx context.Context, id string) error {
+func (q *Queries) DeleteDownloadRequest(ctx context.Context, id int64) error {
 	_, err := q.db.ExecContext(ctx, deleteDownloadRequest, id)
 	return err
 }
 
-const deleteDownloadWant = `-- name: DeleteDownloadWant :exec
-DELETE FROM download_wants WHERE id = ?
-`
-
-func (q *Queries) DeleteDownloadWant(ctx context.Context, id int64) error {
-	_, err := q.db.ExecContext(ctx, deleteDownloadWant, id)
-	return err
-}
-
-const deleteFinishedDownloadRequests = `-- name: DeleteFinishedDownloadRequests :exec
-DELETE FROM download_requests
+const deleteFinishedDownloads = `-- name: DeleteFinishedDownloads :exec
+DELETE FROM download_downloads
 WHERE state IN ('complete', 'cancelled', 'failed')
 `
 
-func (q *Queries) DeleteFinishedDownloadRequests(ctx context.Context) error {
-	_, err := q.db.ExecContext(ctx, deleteFinishedDownloadRequests)
+func (q *Queries) DeleteFinishedDownloads(ctx context.Context) error {
+	_, err := q.db.ExecContext(ctx, deleteFinishedDownloads)
 	return err
 }
 
-const deleteSatisfiedDownloadWants = `-- name: DeleteSatisfiedDownloadWants :exec
-DELETE FROM download_wants WHERE state = 'satisfied'
+const deleteSatisfiedDownloadRequests = `-- name: DeleteSatisfiedDownloadRequests :exec
+DELETE FROM download_requests WHERE state = 'satisfied'
 `
 
-func (q *Queries) DeleteSatisfiedDownloadWants(ctx context.Context) error {
-	_, err := q.db.ExecContext(ctx, deleteSatisfiedDownloadWants)
+func (q *Queries) DeleteSatisfiedDownloadRequests(ctx context.Context) error {
+	_, err := q.db.ExecContext(ctx, deleteSatisfiedDownloadRequests)
 	return err
 }
 
+const getDownload = `-- name: GetDownload :one
+SELECT id, library_id, source, request_id, release_mbid, release_group_mbid,
+       recording_mbid, artist, album, query, expected, state, error,
+       created_at, updated_at
+FROM download_downloads
+WHERE id = ?
+`
+
+func (q *Queries) GetDownload(ctx context.Context, id string) (DownloadDownload, error) {
+	row := q.db.QueryRowContext(ctx, getDownload, id)
+	var i DownloadDownload
+	err := row.Scan(
+		&i.ID,
+		&i.LibraryID,
+		&i.Source,
+		&i.RequestID,
+		&i.ReleaseMbid,
+		&i.ReleaseGroupMbid,
+		&i.RecordingMbid,
+		&i.Artist,
+		&i.Album,
+		&i.Query,
+		&i.Expected,
+		&i.State,
+		&i.Error,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
 const getDownloadItem = `-- name: GetDownloadItem :one
-SELECT id, request_id, provider_id, transport_id, external_id, candidate,
+SELECT id, download_id, provider_id, transport_id, external_id, candidate,
        state, staging_dir, bytes_done, bytes_total, imported_paths,
        error, created_at, updated_at
 FROM download_items
@@ -174,7 +213,7 @@ func (q *Queries) GetDownloadItem(ctx context.Context, id string) (DownloadItem,
 	var i DownloadItem
 	err := row.Scan(
 		&i.ID,
-		&i.RequestID,
+		&i.DownloadID,
 		&i.ProviderID,
 		&i.TransportID,
 		&i.ExternalID,
@@ -213,43 +252,12 @@ func (q *Queries) GetDownloadProvider(ctx context.Context, id int64) (DownloadPr
 }
 
 const getDownloadRequest = `-- name: GetDownloadRequest :one
-SELECT id, library_id, source, want_id, release_mbid, release_group_mbid,
-       recording_mbid, artist, album, query, expected, state, error,
-       created_at, updated_at
-FROM download_requests
-WHERE id = ?
+SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_requests WHERE id = ?
 `
 
-func (q *Queries) GetDownloadRequest(ctx context.Context, id string) (DownloadRequest, error) {
+func (q *Queries) GetDownloadRequest(ctx context.Context, id int64) (DownloadRequest, error) {
 	row := q.db.QueryRowContext(ctx, getDownloadRequest, id)
 	var i DownloadRequest
-	err := row.Scan(
-		&i.ID,
-		&i.LibraryID,
-		&i.Source,
-		&i.WantID,
-		&i.ReleaseMbid,
-		&i.ReleaseGroupMbid,
-		&i.RecordingMbid,
-		&i.Artist,
-		&i.Album,
-		&i.Query,
-		&i.Expected,
-		&i.State,
-		&i.Error,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-	)
-	return i, err
-}
-
-const getDownloadWant = `-- name: GetDownloadWant :one
-SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_wants WHERE id = ?
-`
-
-func (q *Queries) GetDownloadWant(ctx context.Context, id int64) (DownloadWant, error) {
-	row := q.db.QueryRowContext(ctx, getDownloadWant, id)
-	var i DownloadWant
 	err := row.Scan(
 		&i.ID,
 		&i.Mbid,
@@ -272,18 +280,18 @@ func (q *Queries) GetDownloadWant(ctx context.Context, id int64) (DownloadWant,
 	return i, err
 }
 
-const getDownloadWantByMBID = `-- name: GetDownloadWantByMBID :one
-SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_wants WHERE mbid = ? AND library_id = ?
+const getDownloadRequestByMBID = `-- name: GetDownloadRequestByMBID :one
+SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_requests WHERE mbid = ? AND library_id = ?
 `
 
-type GetDownloadWantByMBIDParams struct {
+type GetDownloadRequestByMBIDParams struct {
 	Mbid      string
 	LibraryID int64
 }
 
-func (q *Queries) GetDownloadWantByMBID(ctx context.Context, arg GetDownloadWantByMBIDParams) (DownloadWant, error) {
-	row := q.db.QueryRowContext(ctx, getDownloadWantByMBID, arg.Mbid, arg.LibraryID)
-	var i DownloadWant
+func (q *Queries) GetDownloadRequestByMBID(ctx context.Context, arg GetDownloadRequestByMBIDParams) (DownloadRequest, error) {
+	row := q.db.QueryRowContext(ctx, getDownloadRequestByMBID, arg.Mbid, arg.LibraryID)
+	var i DownloadRequest
 	err := row.Scan(
 		&i.ID,
 		&i.Mbid,
@@ -306,19 +314,19 @@ func (q *Queries) GetDownloadWantByMBID(ctx context.Context, arg GetDownloadWant
 	return i, err
 }
 
-const listChildDownloadWants = `-- name: ListChildDownloadWants :many
-SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_wants WHERE parent_id = ? ORDER BY id
+const listChildDownloadRequests = `-- name: ListChildDownloadRequests :many
+SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_requests WHERE parent_id = ? ORDER BY id
 `
 
-func (q *Queries) ListChildDownloadWants(ctx context.Context, parentID sql.NullInt64) ([]DownloadWant, error) {
-	rows, err := q.db.QueryContext(ctx, listChildDownloadWants, parentID)
+func (q *Queries) ListChildDownloadRequests(ctx context.Context, parentID sql.NullInt64) ([]DownloadRequest, error) {
+	rows, err := q.db.QueryContext(ctx, listChildDownloadRequests, parentID)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []DownloadWant
+	var items []DownloadRequest
 	for rows.Next() {
-		var i DownloadWant
+		var i DownloadRequest
 		if err := rows.Scan(
 			&i.ID,
 			&i.Mbid,
@@ -351,17 +359,17 @@ func (q *Queries) ListChildDownloadWants(ctx context.Context, parentID sql.NullI
 	return items, nil
 }
 
-const listDownloadItemsForRequest = `-- name: ListDownloadItemsForRequest :many
-SELECT id, request_id, provider_id, transport_id, external_id, candidate,
+const listDownloadItemsForDownload = `-- name: ListDownloadItemsForDownload :many
+SELECT id, download_id, provider_id, transport_id, external_id, candidate,
        state, staging_dir, bytes_done, bytes_total, imported_paths,
        error, created_at, updated_at
 FROM download_items
-WHERE request_id = ?
+WHERE download_id = ?
 ORDER BY created_at
 `
 
-func (q *Queries) ListDownloadItemsForRequest(ctx context.Context, requestID string) ([]DownloadItem, error) {
-	rows, err := q.db.QueryContext(ctx, listDownloadItemsForRequest, requestID)
+func (q *Queries) ListDownloadItemsForDownload(ctx context.Context, downloadID string) ([]DownloadItem, error) {
+	rows, err := q.db.QueryContext(ctx, listDownloadItemsForDownload, downloadID)
 	if err != nil {
 		return nil, err
 	}
@@ -371,7 +379,7 @@ func (q *Queries) ListDownloadItemsForRequest(ctx context.Context, requestID str
 		var i DownloadItem
 		if err := rows.Scan(
 			&i.ID,
-			&i.RequestID,
+			&i.DownloadID,
 			&i.ProviderID,
 			&i.TransportID,
 			&i.ExternalID,
@@ -436,16 +444,14 @@ func (q *Queries) ListDownloadProviders(ctx context.Context) ([]DownloadProvider
 }
 
 const listDownloadRequests = `-- name: ListDownloadRequests :many
-SELECT id, library_id, source, want_id, release_mbid, release_group_mbid,
-       recording_mbid, artist, album, query, expected, state, error,
-       created_at, updated_at
-FROM download_requests
-ORDER BY created_at DESC
-LIMIT ?
+SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_requests
+ORDER BY
+    CASE state WHEN 'wanted' THEN 0 WHEN 'paused' THEN 1 ELSE 2 END,
+    artist, title
 `
 
-func (q *Queries) ListDownloadRequests(ctx context.Context, limit int64) ([]DownloadRequest, error) {
-	rows, err := q.db.QueryContext(ctx, listDownloadRequests, limit)
+func (q *Queries) ListDownloadRequests(ctx context.Context) ([]DownloadRequest, error) {
+	rows, err := q.db.QueryContext(ctx, listDownloadRequests)
 	if err != nil {
 		return nil, err
 	}
@@ -453,11 +459,113 @@ func (q *Queries) ListDownloadRequests(ctx context.Context, limit int64) ([]Down
 	var items []DownloadRequest
 	for rows.Next() {
 		var i DownloadRequest
+		if err := rows.Scan(
+			&i.ID,
+			&i.Mbid,
+			&i.Entity,
+			&i.LibraryID,
+			&i.Artist,
+			&i.Title,
+			&i.Scope,
+			&i.Secondary,
+			&i.State,
+			&i.ParentID,
+			&i.Attempts,
+			&i.LastError,
+			&i.LastTriedAt,
+			&i.NextTryAt,
+			&i.ExternalIds,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listDownloadRequestsByEntity = `-- name: ListDownloadRequestsByEntity :many
+SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_requests
+WHERE entity = ? AND state = ?
+ORDER BY id
+`
+
+type ListDownloadRequestsByEntityParams struct {
+	Entity string
+	State  string
+}
+
+func (q *Queries) ListDownloadRequestsByEntity(ctx context.Context, arg ListDownloadRequestsByEntityParams) ([]DownloadRequest, error) {
+	rows, err := q.db.QueryContext(ctx, listDownloadRequestsByEntity, arg.Entity, arg.State)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []DownloadRequest
+	for rows.Next() {
+		var i DownloadRequest
+		if err := rows.Scan(
+			&i.ID,
+			&i.Mbid,
+			&i.Entity,
+			&i.LibraryID,
+			&i.Artist,
+			&i.Title,
+			&i.Scope,
+			&i.Secondary,
+			&i.State,
+			&i.ParentID,
+			&i.Attempts,
+			&i.LastError,
+			&i.LastTriedAt,
+			&i.NextTryAt,
+			&i.ExternalIds,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listDownloads = `-- name: ListDownloads :many
+SELECT id, library_id, source, request_id, release_mbid, release_group_mbid,
+       recording_mbid, artist, album, query, expected, state, error,
+       created_at, updated_at
+FROM download_downloads
+ORDER BY created_at DESC
+LIMIT ?
+`
+
+func (q *Queries) ListDownloads(ctx context.Context, limit int64) ([]DownloadDownload, error) {
+	rows, err := q.db.QueryContext(ctx, listDownloads, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []DownloadDownload
+	for rows.Next() {
+		var i DownloadDownload
 		if err := rows.Scan(
 			&i.ID,
 			&i.LibraryID,
 			&i.Source,
-			&i.WantID,
+			&i.RequestID,
 			&i.ReleaseMbid,
 			&i.ReleaseGroupMbid,
 			&i.RecordingMbid,
@@ -483,108 +591,8 @@ func (q *Queries) ListDownloadRequests(ctx context.Context, limit int64) ([]Down
 	return items, nil
 }
 
-const listDownloadWants = `-- name: ListDownloadWants :many
-SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_wants
-ORDER BY
-    CASE state WHEN 'wanted' THEN 0 WHEN 'paused' THEN 1 ELSE 2 END,
-    artist, title
-`
-
-func (q *Queries) ListDownloadWants(ctx context.Context) ([]DownloadWant, error) {
-	rows, err := q.db.QueryContext(ctx, listDownloadWants)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []DownloadWant
-	for rows.Next() {
-		var i DownloadWant
-		if err := rows.Scan(
-			&i.ID,
-			&i.Mbid,
-			&i.Entity,
-			&i.LibraryID,
-			&i.Artist,
-			&i.Title,
-			&i.Scope,
-			&i.Secondary,
-			&i.State,
-			&i.ParentID,
-			&i.Attempts,
-			&i.LastError,
-			&i.LastTriedAt,
-			&i.NextTryAt,
-			&i.ExternalIds,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const listDownloadWantsByEntity = `-- name: ListDownloadWantsByEntity :many
-SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_wants
-WHERE entity = ? AND state = ?
-ORDER BY id
-`
-
-type ListDownloadWantsByEntityParams struct {
-	Entity string
-	State  string
-}
-
-func (q *Queries) ListDownloadWantsByEntity(ctx context.Context, arg ListDownloadWantsByEntityParams) ([]DownloadWant, error) {
-	rows, err := q.db.QueryContext(ctx, listDownloadWantsByEntity, arg.Entity, arg.State)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []DownloadWant
-	for rows.Next() {
-		var i DownloadWant
-		if err := rows.Scan(
-			&i.ID,
-			&i.Mbid,
-			&i.Entity,
-			&i.LibraryID,
-			&i.Artist,
-			&i.Title,
-			&i.Scope,
-			&i.Secondary,
-			&i.State,
-			&i.ParentID,
-			&i.Attempts,
-			&i.LastError,
-			&i.LastTriedAt,
-			&i.NextTryAt,
-			&i.ExternalIds,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const listDueDownloadWants = `-- name: ListDueDownloadWants :many
-SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_wants
+const listDueDownloadRequests = `-- name: ListDueDownloadRequests :many
+SELECT id, mbid, entity, library_id, artist, title, scope, secondary, state, parent_id, attempts, last_error, last_tried_at, next_try_at, external_ids, created_at, updated_at FROM download_requests
 WHERE state = 'wanted'
   AND entity <> 'artist'
   AND (next_try_at IS NULL OR next_try_at <= CURRENT_TIMESTAMP)
@@ -595,15 +603,15 @@ LIMIT ?
 // Everything the reconciler should act on this pass: wanted, not an
 // artist subscription (those expand rather than download), and either
 // never tried or past its backoff.
-func (q *Queries) ListDueDownloadWants(ctx context.Context, limit int64) ([]DownloadWant, error) {
-	rows, err := q.db.QueryContext(ctx, listDueDownloadWants, limit)
+func (q *Queries) ListDueDownloadRequests(ctx context.Context, limit int64) ([]DownloadRequest, error) {
+	rows, err := q.db.QueryContext(ctx, listDueDownloadRequests, limit)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []DownloadWant
+	var items []DownloadRequest
 	for rows.Next() {
-		var i DownloadWant
+		var i DownloadRequest
 		if err := rows.Scan(
 			&i.ID,
 			&i.Mbid,
@@ -637,7 +645,7 @@ func (q *Queries) ListDueDownloadWants(ctx context.Context, limit int64) ([]Down
 }
 
 const listLiveDownloadItems = `-- name: ListLiveDownloadItems :many
-SELECT id, request_id, provider_id, transport_id, external_id, candidate,
+SELECT id, download_id, provider_id, transport_id, external_id, candidate,
        state, staging_dir, bytes_done, bytes_total, imported_paths,
        error, created_at, updated_at
 FROM download_items
@@ -656,7 +664,7 @@ func (q *Queries) ListLiveDownloadItems(ctx context.Context) ([]DownloadItem, er
 		var i DownloadItem
 		if err := rows.Scan(
 			&i.ID,
-			&i.RequestID,
+			&i.DownloadID,
 			&i.ProviderID,
 			&i.TransportID,
 			&i.ExternalID,
@@ -683,29 +691,29 @@ func (q *Queries) ListLiveDownloadItems(ctx context.Context) ([]DownloadItem, er
 	return items, nil
 }
 
-const listLiveDownloadRequests = `-- name: ListLiveDownloadRequests :many
-SELECT id, library_id, source, want_id, release_mbid, release_group_mbid,
+const listLiveDownloads = `-- name: ListLiveDownloads :many
+SELECT id, library_id, source, request_id, release_mbid, release_group_mbid,
        recording_mbid, artist, album, query, expected, state, error,
        created_at, updated_at
-FROM download_requests
+FROM download_downloads
 WHERE state NOT IN ('complete', 'cancelled', 'failed')
 ORDER BY created_at
 `
 
-func (q *Queries) ListLiveDownloadRequests(ctx context.Context) ([]DownloadRequest, error) {
-	rows, err := q.db.QueryContext(ctx, listLiveDownloadRequests)
+func (q *Queries) ListLiveDownloads(ctx context.Context) ([]DownloadDownload, error) {
+	rows, err := q.db.QueryContext(ctx, listLiveDownloads)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []DownloadRequest
+	var items []DownloadDownload
 	for rows.Next() {
-		var i DownloadRequest
+		var i DownloadDownload
 		if err := rows.Scan(
 			&i.ID,
 			&i.LibraryID,
 			&i.Source,
-			&i.WantID,
+			&i.RequestID,
 			&i.ReleaseMbid,
 			&i.ReleaseGroupMbid,
 			&i.RecordingMbid,
@@ -731,8 +739,8 @@ func (q *Queries) ListLiveDownloadRequests(ctx context.Context) ([]DownloadReque
 	return items, nil
 }
 
-const recordDownloadWantAttempt = `-- name: RecordDownloadWantAttempt :exec
-UPDATE download_wants
+const recordDownloadRequestAttempt = `-- name: RecordDownloadRequestAttempt :exec
+UPDATE download_requests
 SET attempts      = attempts + 1,
     last_error    = ?,
     last_tried_at = CURRENT_TIMESTAMP,
@@ -741,26 +749,26 @@ SET attempts      = attempts + 1,
 WHERE id = ?
 `
 
-type RecordDownloadWantAttemptParams struct {
+type RecordDownloadRequestAttemptParams struct {
 	LastError string
 	NextTryAt sql.NullTime
 	ID        int64
 }
 
-func (q *Queries) RecordDownloadWantAttempt(ctx context.Context, arg RecordDownloadWantAttemptParams) error {
-	_, err := q.db.ExecContext(ctx, recordDownloadWantAttempt, arg.LastError, arg.NextTryAt, arg.ID)
+func (q *Queries) RecordDownloadRequestAttempt(ctx context.Context, arg RecordDownloadRequestAttemptParams) error {
+	_, err := q.db.ExecContext(ctx, recordDownloadRequestAttempt, arg.LastError, arg.NextTryAt, arg.ID)
 	return err
 }
 
-const satisfyDownloadWant = `-- name: SatisfyDownloadWant :exec
-UPDATE download_wants
+const satisfyDownloadRequest = `-- name: SatisfyDownloadRequest :exec
+UPDATE download_requests
 SET state = 'satisfied', last_error = '', next_try_at = NULL,
     updated_at = CURRENT_TIMESTAMP
 WHERE id = ?
 `
 
-func (q *Queries) SatisfyDownloadWant(ctx context.Context, id int64) error {
-	_, err := q.db.ExecContext(ctx, satisfyDownloadWant, id)
+func (q *Queries) SatisfyDownloadRequest(ctx context.Context, id int64) error {
+	_, err := q.db.ExecContext(ctx, satisfyDownloadRequest, id)
 	return err
 }
 
@@ -831,53 +839,53 @@ func (q *Queries) SetDownloadItemState(ctx context.Context, arg SetDownloadItemS
 	return err
 }
 
-const setDownloadRequestState = `-- name: SetDownloadRequestState :exec
+const setDownloadRequestExternalIDs = `-- name: SetDownloadRequestExternalIDs :exec
 UPDATE download_requests
-SET state = ?, error = ?, updated_at = CURRENT_TIMESTAMP
-WHERE id = ?
-`
-
-type SetDownloadRequestStateParams struct {
-	State string
-	Error string
-	ID    string
-}
-
-func (q *Queries) SetDownloadRequestState(ctx context.Context, arg SetDownloadRequestStateParams) error {
-	_, err := q.db.ExecContext(ctx, setDownloadRequestState, arg.State, arg.Error, arg.ID)
-	return err
-}
-
-const setDownloadWantExternalIDs = `-- name: SetDownloadWantExternalIDs :exec
-UPDATE download_wants
 SET external_ids = ?, updated_at = CURRENT_TIMESTAMP
 WHERE id = ?
 `
 
-type SetDownloadWantExternalIDsParams struct {
+type SetDownloadRequestExternalIDsParams struct {
 	ExternalIds string
 	ID          int64
 }
 
-func (q *Queries) SetDownloadWantExternalIDs(ctx context.Context, arg SetDownloadWantExternalIDsParams) error {
-	_, err := q.db.ExecContext(ctx, setDownloadWantExternalIDs, arg.ExternalIds, arg.ID)
+func (q *Queries) SetDownloadRequestExternalIDs(ctx context.Context, arg SetDownloadRequestExternalIDsParams) error {
+	_, err := q.db.ExecContext(ctx, setDownloadRequestExternalIDs, arg.ExternalIds, arg.ID)
 	return err
 }
 
-const setDownloadWantState = `-- name: SetDownloadWantState :exec
-UPDATE download_wants
+const setDownloadRequestState = `-- name: SetDownloadRequestState :exec
+UPDATE download_requests
 SET state = ?, last_error = ?, updated_at = CURRENT_TIMESTAMP
 WHERE id = ?
 `
 
-type SetDownloadWantStateParams struct {
+type SetDownloadRequestStateParams struct {
 	State     string
 	LastError string
 	ID        int64
 }
 
-func (q *Queries) SetDownloadWantState(ctx context.Context, arg SetDownloadWantStateParams) error {
-	_, err := q.db.ExecContext(ctx, setDownloadWantState, arg.State, arg.LastError, arg.ID)
+func (q *Queries) SetDownloadRequestState(ctx context.Context, arg SetDownloadRequestStateParams) error {
+	_, err := q.db.ExecContext(ctx, setDownloadRequestState, arg.State, arg.LastError, arg.ID)
+	return err
+}
+
+const setDownloadState = `-- name: SetDownloadState :exec
+UPDATE download_downloads
+SET state = ?, error = ?, updated_at = CURRENT_TIMESTAMP
+WHERE id = ?
+`
+
+type SetDownloadStateParams struct {
+	State string
+	Error string
+	ID    string
+}
+
+func (q *Queries) SetDownloadState(ctx context.Context, arg SetDownloadStateParams) error {
+	_, err := q.db.ExecContext(ctx, setDownloadState, arg.State, arg.Error, arg.ID)
 	return err
 }
 
@@ -906,25 +914,25 @@ func (q *Queries) UpdateDownloadProvider(ctx context.Context, arg UpdateDownload
 	return err
 }
 
-const upsertDownloadWant = `-- name: UpsertDownloadWant :one
+const upsertDownloadRequest = `-- name: UpsertDownloadRequest :one
 
-INSERT INTO download_wants (
+INSERT INTO download_requests (
     mbid, entity, library_id, artist, title, scope, secondary,
     parent_id, next_try_at
 )
 VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
 ON CONFLICT(mbid, library_id) DO UPDATE SET
     artist     = CASE WHEN excluded.artist <> '' THEN excluded.artist
-                      ELSE download_wants.artist END,
+                      ELSE download_requests.artist END,
     title      = CASE WHEN excluded.title <> '' THEN excluded.title
-                      ELSE download_wants.title END,
+                      ELSE download_requests.title END,
     scope      = excluded.scope,
     secondary  = excluded.secondary,
     updated_at = CURRENT_TIMESTAMP
 RETURNING id
 `
 
-type UpsertDownloadWantParams struct {
+type UpsertDownloadRequestParams struct {
 	Mbid      string
 	Entity    string
 	LibraryID int64
@@ -936,14 +944,14 @@ type UpsertDownloadWantParams struct {
 }
 
 // ---------------------------------------------------------------------
-// Wants
+// Requests (durable "I asked for this" records)
 // ---------------------------------------------------------------------
-// Adding something already wanted is not an error and must not reset
-// the retry clock, so the conflict path only refreshes display text and
-// un-pauses nothing.  scope and secondary are updated because asking
-// again with a wider scope is a real change of intent.
-func (q *Queries) UpsertDownloadWant(ctx context.Context, arg UpsertDownloadWantParams) (int64, error) {
-	row := q.db.QueryRowContext(ctx, upsertDownloadWant,
+// Adding something already requested is not an error and must not
+// reset the retry clock, so the conflict path only refreshes display
+// text and un-pauses nothing.  scope and secondary are updated because
+// asking again with a wider scope is a real change of intent.
+func (q *Queries) UpsertDownloadRequest(ctx context.Context, arg UpsertDownloadRequestParams) (int64, error) {
+	row := q.db.QueryRowContext(ctx, upsertDownloadRequest,
 		arg.Mbid,
 		arg.Entity,
 		arg.LibraryID,

backend/database/sql/sqlcgen/models.go

@@ -74,9 +74,27 @@ type CoverArt struct {
 	MimeType   string
 }
 
+type DownloadDownload struct {
+	ID               string
+	LibraryID        int64
+	Source           string
+	RequestID        sql.NullInt64
+	ReleaseMbid      sql.NullString
+	ReleaseGroupMbid sql.NullString
+	RecordingMbid    sql.NullString
+	Artist           string
+	Album            string
+	Query            string
+	Expected         string
+	State            string
+	Error            string
+	CreatedAt        time.Time
+	UpdatedAt        time.Time
+}
+
 type DownloadItem struct {
 	ID            string
-	RequestID     string
+	DownloadID    string
 	ProviderID    int64
 	TransportID   sql.NullInt64
 	ExternalID    string
@@ -102,24 +120,6 @@ type DownloadProvider struct {
 }
 
 type DownloadRequest struct {
-	ID               string
-	LibraryID        int64
-	Source           string
-	WantID           sql.NullInt64
-	ReleaseMbid      sql.NullString
-	ReleaseGroupMbid sql.NullString
-	RecordingMbid    sql.NullString
-	Artist           string
-	Album            string
-	Query            string
-	Expected         string
-	State            string
-	Error            string
-	CreatedAt        time.Time
-	UpdatedAt        time.Time
-}
-
-type DownloadWant struct {
 	ID          int64
 	Mbid        string
 	Entity      string