feat: download lifecycle — stalled and failed downloads are given up and searched again; imported ones seed, then go (M502 #5523)

Ported from Fabled Librarian's System 104. A new lifecycle poller, every
ten minutes:
- a download the client fails is given up at once;
- one nobody shares, or still fetching its file list, past the stall
  setting (6 h) is asked for again three times, then given up;
- giving up removes the download with its files, holds the release back
  for a week (release_blocks.expires_at), ends the grab and searches the
  album again, with no limit per album;
- a running download the client stops listing for half an hour ends and is
  searched again, not held back; an empty list is not taken as gone;
- an imported download seeds to ratio 2.0 or 14 days, then is removed;
- a download the client would not remove is asked again every pass.

Every condition and act is one open row per (client, download, condition)
in download_interventions. Activity shows what is wrong with a download and
how often it was retried, why one ended, its seeding, and a banner for a
client that does not answer. A running download can be given up by hand
(set aside for good). The seed ratio, seed days and stall hours are on the
search settings card. The download client lookup moves to
acquire.DownloadClientFor, shared by the importer and the lifecycle.

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

internal/db/dbq/imports.sql.go

@@ -16,7 +16,7 @@ UPDATE grabs
    SET import_state = 'importing', import_attempts = import_attempts + 1,
        import_updated_at = now(), progress = 1
  WHERE id = $1 AND ended_at IS NULL AND import_state IN ('', 'downloading', 'waiting')
-RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination
+RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination, seeding, ratio, seed_released_at
 `
 
 // Takes a finished download for import. The update is the lock: a second
@@ -52,6 +52,9 @@ func (q *Queries) ClaimGrabImport(ctx context.Context, id pgtype.UUID) (Grab, er
 		&i.ImportedAt,
 		&i.ImportedFiles,
 		&i.Destination,
+		&i.Seeding,
+		&i.Ratio,
+		&i.SeedReleasedAt,
 	)
 	return i, err
 }
@@ -60,7 +63,7 @@ const forceGrabImport = `-- name: ForceGrabImport :one
 UPDATE grabs
    SET import_state = '', import_forced = true, import_reason = '', import_updated_at = now()
  WHERE id = $1 AND ended_at IS NULL AND import_state IN ('review', 'failed')
-RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination
+RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination, seeding, ratio, seed_released_at
 `
 
 // "Import anyway": the next pass imports the download whatever the check said.
@@ -95,12 +98,15 @@ func (q *Queries) ForceGrabImport(ctx context.Context, id pgtype.UUID) (Grab, er
 		&i.ImportedAt,
 		&i.ImportedFiles,
 		&i.Destination,
+		&i.Seeding,
+		&i.Ratio,
+		&i.SeedReleasedAt,
 	)
 	return i, err
 }
 
 const getGrab = `-- name: GetGrab :one
-SELECT id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination FROM grabs WHERE id = $1
+SELECT id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination, seeding, ratio, seed_released_at FROM grabs WHERE id = $1
 `
 
 func (q *Queries) GetGrab(ctx context.Context, id pgtype.UUID) (Grab, error) {
@@ -134,6 +140,9 @@ func (q *Queries) GetGrab(ctx context.Context, id pgtype.UUID) (Grab, error) {
 		&i.ImportedAt,
 		&i.ImportedFiles,
 		&i.Destination,
+		&i.Seeding,
+		&i.Ratio,
+		&i.SeedReleasedAt,
 	)
 	return i, err
 }
@@ -202,9 +211,16 @@ const listGrabs = `-- name: ListGrabs :many
 SELECT g.id, g.want_id, g.name, g.indexer, g.client, g.quality, g.origin, g.forced,
        g.grabbed_at, g.ended_at, g.end_reason, g.end_detail, g.progress, g.import_state,
        g.import_reason, g.import_detail, g.import_updated_at, g.imported_at, g.imported_files,
-       g.destination, w.title AS want_title, w.artist_name AS want_artist
+       g.destination, g.seeding, g.ratio, g.seed_released_at,
+       w.title AS want_title, w.artist_name AS want_artist,
+       di.trigger AS condition, di.detail AS condition_detail, di.remediations AS condition_retries,
+       di.first_seen AS condition_since
   FROM grabs g
   LEFT JOIN wants w ON w.id = g.want_id
+  LEFT JOIN download_interventions di
+         ON di.id = (SELECT x.id FROM download_interventions x
+                      WHERE x.grab_id = g.id AND x.outcome = 'open'
+                      ORDER BY x.last_seen DESC LIMIT 1)
  ORDER BY (g.ended_at IS NULL AND g.import_state IN ('review', 'failed')) DESC,
           g.ended_at IS NULL DESC, g.grabbed_at DESC, g.id
  LIMIT $2 OFFSET $1
@@ -216,32 +232,40 @@ type ListGrabsParams struct {
 }
 
 type ListGrabsRow struct {
-	ID              pgtype.UUID
-	WantID          pgtype.UUID
-	Name            string
-	Indexer         string
-	Client          string
-	Quality         string
-	Origin          string
-	Forced          bool
-	GrabbedAt       pgtype.Timestamptz
-	EndedAt         pgtype.Timestamptz
-	EndReason       string
-	EndDetail       string
-	Progress        float32
-	ImportState     string
-	ImportReason    string
-	ImportDetail    []byte
-	ImportUpdatedAt pgtype.Timestamptz
-	ImportedAt      pgtype.Timestamptz
-	ImportedFiles   int32
-	Destination     string
-	WantTitle       *string
-	WantArtist      *string
+	ID               pgtype.UUID
+	WantID           pgtype.UUID
+	Name             string
+	Indexer          string
+	Client           string
+	Quality          string
+	Origin           string
+	Forced           bool
+	GrabbedAt        pgtype.Timestamptz
+	EndedAt          pgtype.Timestamptz
+	EndReason        string
+	EndDetail        string
+	Progress         float32
+	ImportState      string
+	ImportReason     string
+	ImportDetail     []byte
+	ImportUpdatedAt  pgtype.Timestamptz
+	ImportedAt       pgtype.Timestamptz
+	ImportedFiles    int32
+	Destination      string
+	Seeding          bool
+	Ratio            float32
+	SeedReleasedAt   pgtype.Timestamptz
+	WantTitle        *string
+	WantArtist       *string
+	Condition        *string
+	ConditionDetail  *string
+	ConditionRetries *int32
+	ConditionSince   pgtype.Timestamptz
 }
 
 // The Wanted view's Activity tab: downloads waiting on a person first, then
-// the rest still running, then the ended ones newest first.
+// the rest still running, then the ended ones newest first. Each carries
+// what is wrong with it now, if anything (#5523).
 func (q *Queries) ListGrabs(ctx context.Context, arg ListGrabsParams) ([]ListGrabsRow, error) {
 	rows, err := q.db.Query(ctx, listGrabs, arg.Skip, arg.MaxRows)
 	if err != nil {
@@ -272,8 +296,15 @@ func (q *Queries) ListGrabs(ctx context.Context, arg ListGrabsParams) ([]ListGra
 			&i.ImportedAt,
 			&i.ImportedFiles,
 			&i.Destination,
+			&i.Seeding,
+			&i.Ratio,
+			&i.SeedReleasedAt,
 			&i.WantTitle,
 			&i.WantArtist,
+			&i.Condition,
+			&i.ConditionDetail,
+			&i.ConditionRetries,
+			&i.ConditionSince,
 		); err != nil {
 			return nil, err
 		}
@@ -287,7 +318,7 @@ func (q *Queries) ListGrabs(ctx context.Context, arg ListGrabsParams) ([]ListGra
 
 const listLiveGrabs = `-- name: ListLiveGrabs :many
 
-SELECT g.id, g.want_id, g.info_hash, g.name, g.key, g.indexer, g.source, g.client, g.save_path, g.quality, g.origin, g.forced, g.grabbed_by, g.grabbed_at, g.ended_at, g.end_reason, g.end_detail, g.progress, g.import_state, g.import_reason, g.import_detail, g.import_forced, g.import_attempts, g.import_updated_at, g.imported_at, g.imported_files, g.destination, w.release_group_mbid, w.artist_mbid, w.artist_name, w.title AS want_title,
+SELECT g.id, g.want_id, g.info_hash, g.name, g.key, g.indexer, g.source, g.client, g.save_path, g.quality, g.origin, g.forced, g.grabbed_by, g.grabbed_at, g.ended_at, g.end_reason, g.end_detail, g.progress, g.import_state, g.import_reason, g.import_detail, g.import_forced, g.import_attempts, g.import_updated_at, g.imported_at, g.imported_files, g.destination, g.seeding, g.ratio, g.seed_released_at, w.release_group_mbid, w.artist_mbid, w.artist_name, w.title AS want_title,
        w.reason AS want_reason, w.album_id AS want_album_id
   FROM grabs g
   LEFT JOIN wants w ON w.id = g.want_id
@@ -323,6 +354,9 @@ type ListLiveGrabsRow struct {
 	ImportedAt       pgtype.Timestamptz
 	ImportedFiles    int32
 	Destination      string
+	Seeding          bool
+	Ratio            float32
+	SeedReleasedAt   pgtype.Timestamptz
 	ReleaseGroupMbid *string
 	ArtistMbid       *string
 	ArtistName       *string
@@ -370,6 +404,9 @@ func (q *Queries) ListLiveGrabs(ctx context.Context) ([]ListLiveGrabsRow, error)
 			&i.ImportedAt,
 			&i.ImportedFiles,
 			&i.Destination,
+			&i.Seeding,
+			&i.Ratio,
+			&i.SeedReleasedAt,
 			&i.ReleaseGroupMbid,
 			&i.ArtistMbid,
 			&i.ArtistName,
@@ -388,10 +425,11 @@ func (q *Queries) ListLiveGrabs(ctx context.Context) ([]ListLiveGrabsRow, error)
 }
 
 const listReleaseBlocksPage = `-- name: ListReleaseBlocksPage :many
-SELECT b.info_hash, b.name, b.reason, b.detail, b.blocked_at, w.title AS want_title,
+SELECT b.info_hash, b.name, b.reason, b.detail, b.blocked_at, b.expires_at, w.title AS want_title,
        w.artist_name AS want_artist
   FROM release_blocks b
   LEFT JOIN wants w ON w.id = b.want_id
+ WHERE b.expires_at IS NULL OR b.expires_at > now()
  ORDER BY b.blocked_at DESC, b.info_hash
  LIMIT $2 OFFSET $1
 `
@@ -407,6 +445,7 @@ type ListReleaseBlocksPageRow struct {
 	Reason     string
 	Detail     string
 	BlockedAt  pgtype.Timestamptz
+	ExpiresAt  pgtype.Timestamptz
 	WantTitle  *string
 	WantArtist *string
 }
@@ -426,6 +465,7 @@ func (q *Queries) ListReleaseBlocksPage(ctx context.Context, arg ListReleaseBloc
 			&i.Reason,
 			&i.Detail,
 			&i.BlockedAt,
+			&i.ExpiresAt,
 			&i.WantTitle,
 			&i.WantArtist,
 		); err != nil {
@@ -522,13 +562,16 @@ UPDATE grabs
        import_updated_at = now(),
        import_forced = false,
        imported_at = CASE WHEN $1::text = 'imported' THEN now() ELSE imported_at END,
+       -- The files were copied, so an imported download goes on sharing
+       -- until the lifecycle removes it (#5523).
+       seeding = $1::text = 'imported',
        imported_files = $4,
        destination = $5,
        ended_at = CASE WHEN $6::text <> '' THEN now() ELSE ended_at END,
        end_reason = $6,
        end_detail = CASE WHEN $6::text <> '' THEN $2::text ELSE end_detail END
  WHERE id = $7
-RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination
+RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination, seeding, ratio, seed_released_at
 `
 
 type RecordImportParams struct {
@@ -582,6 +625,9 @@ func (q *Queries) RecordImport(ctx context.Context, arg RecordImportParams) (Gra
 		&i.ImportedAt,
 		&i.ImportedFiles,
 		&i.Destination,
+		&i.Seeding,
+		&i.Ratio,
+		&i.SeedReleasedAt,
 	)
 	return i, err
 }
@@ -591,7 +637,7 @@ UPDATE grabs g
    SET want_id = $1
  WHERE g.id = $2 AND g.ended_at IS NULL
    AND NOT EXISTS (SELECT 1 FROM grabs o WHERE o.want_id = $1 AND o.ended_at IS NULL)
-RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination
+RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination, seeding, ratio, seed_released_at
 `
 
 type RehomeGrabParams struct {
@@ -632,6 +678,9 @@ func (q *Queries) RehomeGrab(ctx context.Context, arg RehomeGrabParams) (Grab, e
 		&i.ImportedAt,
 		&i.ImportedFiles,
 		&i.Destination,
+		&i.Seeding,
+		&i.Ratio,
+		&i.SeedReleasedAt,
 	)
 	return i, err
 }
@@ -640,7 +689,7 @@ const retryGrabImport = `-- name: RetryGrabImport :one
 UPDATE grabs
    SET import_state = '', import_reason = '', import_updated_at = now()
  WHERE id = $1 AND ended_at IS NULL AND import_state = 'failed'
-RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination
+RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination, seeding, ratio, seed_released_at
 `
 
 func (q *Queries) RetryGrabImport(ctx context.Context, id pgtype.UUID) (Grab, error) {
@@ -674,6 +723,9 @@ func (q *Queries) RetryGrabImport(ctx context.Context, id pgtype.UUID) (Grab, er
 		&i.ImportedAt,
 		&i.ImportedFiles,
 		&i.Destination,
+		&i.Seeding,
+		&i.Ratio,
+		&i.SeedReleasedAt,
 	)
 	return i, err
 }

internal/db/dbq/lifecycle.sql.go

@@ -0,0 +1,389 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+// source: lifecycle.sql
+
+package dbq
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+const countRemediation = `-- name: CountRemediation :one
+UPDATE download_interventions
+   SET remediations = remediations + 1,
+       action       = $1,
+       last_seen    = now(),
+       outcome      = CASE WHEN $1::text IN ('given_up', 'removed') THEN 'resolved' ELSE outcome END,
+       settled_at   = CASE WHEN $1::text IN ('given_up', 'removed') THEN now() ELSE settled_at END
+ WHERE client = $2 AND info_hash = $3
+   AND trigger = $4 AND outcome = 'open'
+RETURNING remediations
+`
+
+type CountRemediationParams struct {
+	Action   string
+	Client   string
+	InfoHash string
+	Trigger  string
+}
+
+// Minstrel acted on an open condition. A retry climbs the ladder; giving up
+// or removing ends the condition, since what it was about is gone. Written
+// before the act, so a retry that happened is never uncounted.
+func (q *Queries) CountRemediation(ctx context.Context, arg CountRemediationParams) (int32, error) {
+	row := q.db.QueryRow(ctx, countRemediation,
+		arg.Action,
+		arg.Client,
+		arg.InfoHash,
+		arg.Trigger,
+	)
+	var remediations int32
+	err := row.Scan(&remediations)
+	return remediations, err
+}
+
+const deleteExpiredBlocks = `-- name: DeleteExpiredBlocks :execrows
+DELETE FROM release_blocks WHERE expires_at IS NOT NULL AND expires_at <= now()
+`
+
+// A release given up on is held back for a while; after that the search may
+// take it again.
+func (q *Queries) DeleteExpiredBlocks(ctx context.Context) (int64, error) {
+	result, err := q.db.Exec(ctx, deleteExpiredBlocks)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected(), nil
+}
+
+const giveUpGrab = `-- name: GiveUpGrab :one
+UPDATE grabs
+   SET ended_at = now(), end_reason = $1, end_detail = $2,
+       import_updated_at = now()
+ WHERE id = $3 AND ended_at IS NULL AND import_state = ANY($4::text[])
+RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination, seeding, ratio, seed_released_at
+`
+
+type GiveUpGrabParams struct {
+	EndReason string
+	EndDetail string
+	ID        pgtype.UUID
+	States    []string
+}
+
+// Ends a running grab, given up on. Only from the states named: the update
+// is the lock against an import that claimed the download meanwhile.
+func (q *Queries) GiveUpGrab(ctx context.Context, arg GiveUpGrabParams) (Grab, error) {
+	row := q.db.QueryRow(ctx, giveUpGrab,
+		arg.EndReason,
+		arg.EndDetail,
+		arg.ID,
+		arg.States,
+	)
+	var i Grab
+	err := row.Scan(
+		&i.ID,
+		&i.WantID,
+		&i.InfoHash,
+		&i.Name,
+		&i.Key,
+		&i.Indexer,
+		&i.Source,
+		&i.Client,
+		&i.SavePath,
+		&i.Quality,
+		&i.Origin,
+		&i.Forced,
+		&i.GrabbedBy,
+		&i.GrabbedAt,
+		&i.EndedAt,
+		&i.EndReason,
+		&i.EndDetail,
+		&i.Progress,
+		&i.ImportState,
+		&i.ImportReason,
+		&i.ImportDetail,
+		&i.ImportForced,
+		&i.ImportAttempts,
+		&i.ImportUpdatedAt,
+		&i.ImportedAt,
+		&i.ImportedFiles,
+		&i.Destination,
+		&i.Seeding,
+		&i.Ratio,
+		&i.SeedReleasedAt,
+	)
+	return i, err
+}
+
+const listClientsDown = `-- name: ListClientsDown :many
+SELECT client, detail, first_seen FROM download_interventions
+ WHERE trigger = 'client_unreachable' AND outcome = 'open'
+ ORDER BY client
+`
+
+type ListClientsDownRow struct {
+	Client    string
+	Detail    string
+	FirstSeen pgtype.Timestamptz
+}
+
+// Download clients not answering now, for the Activity tab.
+func (q *Queries) ListClientsDown(ctx context.Context) ([]ListClientsDownRow, error) {
+	rows, err := q.db.Query(ctx, listClientsDown)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []ListClientsDownRow
+	for rows.Next() {
+		var i ListClientsDownRow
+		if err := rows.Scan(&i.Client, &i.Detail, &i.FirstSeen); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listLeftovers = `-- name: ListLeftovers :many
+SELECT id, client, info_hash, grab_id, name, trigger, action, outcome, detail, observations, remediations, first_seen, last_seen, settled_at FROM download_interventions
+ WHERE trigger = 'not_removed' AND outcome = 'open' AND info_hash <> ''
+ ORDER BY first_seen
+`
+
+// Downloads given up on that the client would not remove; each pass asks
+// again.
+func (q *Queries) ListLeftovers(ctx context.Context) ([]DownloadIntervention, error) {
+	rows, err := q.db.Query(ctx, listLeftovers)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []DownloadIntervention
+	for rows.Next() {
+		var i DownloadIntervention
+		if err := rows.Scan(
+			&i.ID,
+			&i.Client,
+			&i.InfoHash,
+			&i.GrabID,
+			&i.Name,
+			&i.Trigger,
+			&i.Action,
+			&i.Outcome,
+			&i.Detail,
+			&i.Observations,
+			&i.Remediations,
+			&i.FirstSeen,
+			&i.LastSeen,
+			&i.SettledAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listSeedingGrabs = `-- name: ListSeedingGrabs :many
+SELECT id, client, info_hash, name, imported_at FROM grabs
+ WHERE seeding AND seed_released_at IS NULL
+ ORDER BY imported_at, id
+`
+
+type ListSeedingGrabsRow struct {
+	ID         pgtype.UUID
+	Client     string
+	InfoHash   string
+	Name       string
+	ImportedAt pgtype.Timestamptz
+}
+
+// Imported downloads still sharing, oldest import first.
+func (q *Queries) ListSeedingGrabs(ctx context.Context) ([]ListSeedingGrabsRow, error) {
+	rows, err := q.db.Query(ctx, listSeedingGrabs)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []ListSeedingGrabsRow
+	for rows.Next() {
+		var i ListSeedingGrabsRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.Client,
+			&i.InfoHash,
+			&i.Name,
+			&i.ImportedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const liveGrabOnHash = `-- name: LiveGrabOnHash :one
+SELECT EXISTS (SELECT 1 FROM grabs WHERE info_hash = $1 AND ended_at IS NULL)::bool
+`
+
+func (q *Queries) LiveGrabOnHash(ctx context.Context, infoHash string) (bool, error) {
+	row := q.db.QueryRow(ctx, liveGrabOnHash, infoHash)
+	var column_1 bool
+	err := row.Scan(&column_1)
+	return column_1, err
+}
+
+const raiseIntervention = `-- name: RaiseIntervention :one
+
+INSERT INTO download_interventions (client, info_hash, grab_id, name, trigger, detail)
+VALUES ($1, $2, $3, $4,
+        $5, $6)
+ON CONFLICT (client, info_hash, trigger) WHERE outcome = 'open' DO UPDATE SET
+    observations = download_interventions.observations + 1,
+    last_seen    = now(),
+    detail       = EXCLUDED.detail,
+    grab_id      = COALESCE(EXCLUDED.grab_id, download_interventions.grab_id),
+    name         = CASE WHEN EXCLUDED.name <> '' THEN EXCLUDED.name ELSE download_interventions.name END
+RETURNING id, client, info_hash, grab_id, name, trigger, action, outcome, detail, observations, remediations, first_seen, last_seen, settled_at
+`
+
+type RaiseInterventionParams struct {
+	Client   string
+	InfoHash string
+	GrabID   pgtype.UUID
+	Name     string
+	Trigger  string
+	Detail   string
+}
+
+// The download lifecycle (M502 #5523): the intervention ledger, giving a
+// download up, and seeding after import.
+// A condition seen, or seen again: a second pass lands on the open row, so
+// a download stuck for a week is one row that says how long. The name only
+// improves, and the detail is the latest word.
+func (q *Queries) RaiseIntervention(ctx context.Context, arg RaiseInterventionParams) (DownloadIntervention, error) {
+	row := q.db.QueryRow(ctx, raiseIntervention,
+		arg.Client,
+		arg.InfoHash,
+		arg.GrabID,
+		arg.Name,
+		arg.Trigger,
+		arg.Detail,
+	)
+	var i DownloadIntervention
+	err := row.Scan(
+		&i.ID,
+		&i.Client,
+		&i.InfoHash,
+		&i.GrabID,
+		&i.Name,
+		&i.Trigger,
+		&i.Action,
+		&i.Outcome,
+		&i.Detail,
+		&i.Observations,
+		&i.Remediations,
+		&i.FirstSeen,
+		&i.LastSeen,
+		&i.SettledAt,
+	)
+	return i, err
+}
+
+const releaseSeed = `-- name: ReleaseSeed :exec
+UPDATE grabs SET seed_released_at = now() WHERE id = $1 AND seed_released_at IS NULL
+`
+
+// The seeding download was removed, or found gone.
+func (q *Queries) ReleaseSeed(ctx context.Context, id pgtype.UUID) error {
+	_, err := q.db.Exec(ctx, releaseSeed, id)
+	return err
+}
+
+const setGrabRatio = `-- name: SetGrabRatio :exec
+UPDATE grabs SET ratio = $1 WHERE id = $2
+`
+
+type SetGrabRatioParams struct {
+	Ratio float32
+	ID    pgtype.UUID
+}
+
+func (q *Queries) SetGrabRatio(ctx context.Context, arg SetGrabRatioParams) error {
+	_, err := q.db.Exec(ctx, setGrabRatio, arg.Ratio, arg.ID)
+	return err
+}
+
+const settleEndedGrabs = `-- name: SettleEndedGrabs :execrows
+UPDATE download_interventions di
+   SET outcome = 'resolved', settled_at = now(), last_seen = now()
+  FROM grabs g
+ WHERE g.id = di.grab_id AND g.ended_at IS NOT NULL
+   AND di.outcome = 'open' AND di.trigger <> 'not_removed'
+`
+
+// What was wrong with a download whose grab has ended (imported, refused,
+// given up) is over, except a download left in the client to remove.
+func (q *Queries) SettleEndedGrabs(ctx context.Context) (int64, error) {
+	result, err := q.db.Exec(ctx, settleEndedGrabs)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected(), nil
+}
+
+const settleIntervention = `-- name: SettleIntervention :execrows
+UPDATE download_interventions
+   SET outcome = 'resolved', settled_at = now(), last_seen = now()
+ WHERE client = $1 AND info_hash = $2
+   AND trigger = $3 AND outcome = 'open'
+`
+
+type SettleInterventionParams struct {
+	Client   string
+	InfoHash string
+	Trigger  string
+}
+
+// The condition cleared.
+func (q *Queries) SettleIntervention(ctx context.Context, arg SettleInterventionParams) (int64, error) {
+	result, err := q.db.Exec(ctx, settleIntervention, arg.Client, arg.InfoHash, arg.Trigger)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected(), nil
+}
+
+const settleInterventionsFor = `-- name: SettleInterventionsFor :execrows
+UPDATE download_interventions
+   SET outcome = 'resolved', settled_at = now(), last_seen = now()
+ WHERE client = $1 AND info_hash = $2 AND outcome = 'open'
+`
+
+type SettleInterventionsForParams struct {
+	Client   string
+	InfoHash string
+}
+
+// Everything open about one download is over: it is gone from the client.
+func (q *Queries) SettleInterventionsFor(ctx context.Context, arg SettleInterventionsForParams) (int64, error) {
+	result, err := q.db.Exec(ctx, settleInterventionsFor, arg.Client, arg.InfoHash)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected(), nil
+}

internal/db/dbq/models.go

@@ -226,6 +226,9 @@ type AcquisitionSetting struct {
 	LastPass            []byte
 	UpdatedAt           pgtype.Timestamptz
 	ImportRoot          string
+	SeedRatio           float32
+	SeedDays            int32
+	StallHours          int32
 }
 
 type Album struct {
@@ -355,6 +358,23 @@ type DiscoverTuning struct {
 	UpdatedAt        pgtype.Timestamptz
 }
 
+type DownloadIntervention struct {
+	ID           pgtype.UUID
+	Client       string
+	InfoHash     string
+	GrabID       pgtype.UUID
+	Name         string
+	Trigger      string
+	Action       string
+	Outcome      string
+	Detail       string
+	Observations int32
+	Remediations int32
+	FirstSeen    pgtype.Timestamptz
+	LastSeen     pgtype.Timestamptz
+	SettledAt    pgtype.Timestamptz
+}
+
 type DuplicateGroup struct {
 	ID                    pgtype.UUID
 	MemberKey             string
@@ -459,6 +479,9 @@ type Grab struct {
 	ImportedAt      pgtype.Timestamptz
 	ImportedFiles   int32
 	Destination     string
+	Seeding         bool
+	Ratio           float32
+	SeedReleasedAt  pgtype.Timestamptz
 }
 
 type LibraryChange struct {
@@ -701,6 +724,7 @@ type ReleaseBlock struct {
 	WantID    pgtype.UUID
 	BlockedBy pgtype.UUID
 	BlockedAt pgtype.Timestamptz
+	ExpiresAt pgtype.Timestamptz
 }
 
 type ReleaseTypeProfile struct {

internal/db/dbq/search.sql.go

@@ -12,11 +12,13 @@ import (
 )
 
 const blockRelease = `-- name: BlockRelease :exec
-INSERT INTO release_blocks (info_hash, name, reason, detail, want_id, blocked_by)
+INSERT INTO release_blocks (info_hash, name, reason, detail, want_id, blocked_by, expires_at)
 VALUES ($1, $2, $3, $4,
-        $5, $6)
+        $5, $6, $7)
 ON CONFLICT (info_hash) DO UPDATE
-   SET reason = EXCLUDED.reason, detail = EXCLUDED.detail, blocked_at = now()
+   SET reason = EXCLUDED.reason, detail = EXCLUDED.detail, blocked_at = now(),
+       expires_at = EXCLUDED.expires_at, blocked_by = EXCLUDED.blocked_by
+ WHERE release_blocks.expires_at IS NOT NULL OR EXCLUDED.expires_at IS NULL
 `
 
 type BlockReleaseParams struct {
@@ -26,8 +28,12 @@ type BlockReleaseParams struct {
 	Detail    string
 	WantID    pgtype.UUID
 	BlockedBy pgtype.UUID
+	ExpiresAt pgtype.Timestamptz
 }
 
+// A release set aside. expires_at NULL is for good. A block for good is never
+// shortened by a timed one: only a timed block, or another for good, is
+// replaced.
 func (q *Queries) BlockRelease(ctx context.Context, arg BlockReleaseParams) error {
 	_, err := q.db.Exec(ctx, blockRelease,
 		arg.InfoHash,
@@ -36,6 +42,7 @@ func (q *Queries) BlockRelease(ctx context.Context, arg BlockReleaseParams) erro
 		arg.Detail,
 		arg.WantID,
 		arg.BlockedBy,
+		arg.ExpiresAt,
 	)
 	return err
 }
@@ -89,7 +96,7 @@ func (q *Queries) EndGrab(ctx context.Context, arg EndGrabParams) error {
 
 const getAcquisitionSettings = `-- name: GetAcquisitionSettings :one
 
-SELECT id, auto_grab, search_interval_hours, allowed_qualities, last_pass_at, last_pass, updated_at, import_root FROM acquisition_settings WHERE id = true
+SELECT id, auto_grab, search_interval_hours, allowed_qualities, last_pass_at, last_pass, updated_at, import_root, seed_ratio, seed_days, stall_hours FROM acquisition_settings WHERE id = true
 `
 
 // Searching for wants and grabbing releases (M502 #5521).
@@ -105,12 +112,15 @@ func (q *Queries) GetAcquisitionSettings(ctx context.Context) (AcquisitionSettin
 		&i.LastPass,
 		&i.UpdatedAt,
 		&i.ImportRoot,
+		&i.SeedRatio,
+		&i.SeedDays,
+		&i.StallHours,
 	)
 	return i, err
 }
 
 const getLiveGrab = `-- name: GetLiveGrab :one
-SELECT id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination FROM grabs WHERE want_id = $1 AND ended_at IS NULL
+SELECT id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination, seeding, ratio, seed_released_at FROM grabs WHERE want_id = $1 AND ended_at IS NULL
 `
 
 func (q *Queries) GetLiveGrab(ctx context.Context, wantID pgtype.UUID) (Grab, error) {
@@ -144,6 +154,9 @@ func (q *Queries) GetLiveGrab(ctx context.Context, wantID pgtype.UUID) (Grab, er
 		&i.ImportedAt,
 		&i.ImportedFiles,
 		&i.Destination,
+		&i.Seeding,
+		&i.Ratio,
+		&i.SeedReleasedAt,
 	)
 	return i, err
 }
@@ -230,7 +243,7 @@ INSERT INTO grabs (want_id, info_hash, name, key, indexer, source, client, save_
 VALUES ($1, $2, $3, $4, $5,
         $6, $7, $8, $9,
         $10, $11, $12)
-RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination
+RETURNING id, want_id, info_hash, name, key, indexer, source, client, save_path, quality, origin, forced, grabbed_by, grabbed_at, ended_at, end_reason, end_detail, progress, import_state, import_reason, import_detail, import_forced, import_attempts, import_updated_at, imported_at, imported_files, destination, seeding, ratio, seed_released_at
 `
 
 type InsertGrabParams struct {
@@ -292,6 +305,9 @@ func (q *Queries) InsertGrab(ctx context.Context, arg InsertGrabParams) (Grab, e
 		&i.ImportedAt,
 		&i.ImportedFiles,
 		&i.Destination,
+		&i.Seeding,
+		&i.Ratio,
+		&i.SeedReleasedAt,
 	)
 	return i, err
 }
@@ -350,9 +366,13 @@ func (q *Queries) InsertWantCandidate(ctx context.Context, arg InsertWantCandida
 }
 
 const listReleaseBlocks = `-- name: ListReleaseBlocks :many
-SELECT info_hash, name, reason, detail, want_id, blocked_by, blocked_at FROM release_blocks ORDER BY blocked_at DESC
+SELECT info_hash, name, reason, detail, want_id, blocked_by, blocked_at, expires_at FROM release_blocks
+ WHERE expires_at IS NULL OR expires_at > now()
+ ORDER BY blocked_at DESC
 `
 
+// Every release set aside and still held back: a stalled one lifts by itself
+// at expires_at (#5523).
 func (q *Queries) ListReleaseBlocks(ctx context.Context) ([]ReleaseBlock, error) {
 	rows, err := q.db.Query(ctx, listReleaseBlocks)
 	if err != nil {
@@ -370,6 +390,7 @@ func (q *Queries) ListReleaseBlocks(ctx context.Context) ([]ReleaseBlock, error)
 			&i.WantID,
 			&i.BlockedBy,
 			&i.BlockedAt,
+			&i.ExpiresAt,
 		); err != nil {
 			return nil, err
 		}
@@ -582,9 +603,12 @@ UPDATE acquisition_settings
        search_interval_hours = $2,
        allowed_qualities     = $3,
        import_root           = $4,
+       seed_ratio            = $5,
+       seed_days             = $6,
+       stall_hours           = $7,
        updated_at            = now()
  WHERE id = true
-RETURNING id, auto_grab, search_interval_hours, allowed_qualities, last_pass_at, last_pass, updated_at, import_root
+RETURNING id, auto_grab, search_interval_hours, allowed_qualities, last_pass_at, last_pass, updated_at, import_root, seed_ratio, seed_days, stall_hours
 `
 
 type UpdateAcquisitionSettingsParams struct {
@@ -592,6 +616,9 @@ type UpdateAcquisitionSettingsParams struct {
 	SearchIntervalHours int32
 	AllowedQualities    []string
 	ImportRoot          string
+	SeedRatio           float32
+	SeedDays            int32
+	StallHours          int32
 }
 
 func (q *Queries) UpdateAcquisitionSettings(ctx context.Context, arg UpdateAcquisitionSettingsParams) (AcquisitionSetting, error) {
@@ -600,6 +627,9 @@ func (q *Queries) UpdateAcquisitionSettings(ctx context.Context, arg UpdateAcqui
 		arg.SearchIntervalHours,
 		arg.AllowedQualities,
 		arg.ImportRoot,
+		arg.SeedRatio,
+		arg.SeedDays,
+		arg.StallHours,
 	)
 	var i AcquisitionSetting
 	err := row.Scan(
@@ -611,6 +641,9 @@ func (q *Queries) UpdateAcquisitionSettings(ctx context.Context, arg UpdateAcqui
 		&i.LastPass,
 		&i.UpdatedAt,
 		&i.ImportRoot,
+		&i.SeedRatio,
+		&i.SeedDays,
+		&i.StallHours,
 	)
 	return i, err
 }

internal/db/dbq/wanted.sql.go

@@ -30,7 +30,8 @@ SELECT COUNT(*) FILTER (WHERE fulfilled_at IS NULL AND reason <> 'missing')::big
        (SELECT COUNT(*) FROM grabs WHERE ended_at IS NULL)::bigint                  AS activity,
        (SELECT COUNT(*) FROM grabs
          WHERE ended_at IS NULL AND import_state IN ('review', 'failed'))::bigint   AS attention,
-       (SELECT COUNT(*) FROM release_blocks)::bigint                                AS blocked
+       (SELECT COUNT(*) FROM release_blocks b
+         WHERE b.expires_at IS NULL OR b.expires_at > now())::bigint               AS blocked
   FROM wants
 `
 
@@ -537,7 +538,7 @@ SELECT w.id, w.release_group_mbid, w.artist_mbid, w.artist_name, w.title, w.reas
        gr.id AS grab_id, gr.name AS grab_name, gr.grabbed_at, gr.origin AS grab_origin,
        gr.quality AS grab_quality, gr.ended_at AS grab_ended_at, gr.end_reason AS grab_end_reason,
        gr.progress AS grab_progress, gr.import_state AS grab_import_state,
-       gr.import_reason AS grab_import_reason, gr.imported_at AS grab_imported_at,
+       gr.import_reason AS grab_import_reason, gr.end_detail AS grab_end_detail, gr.imported_at AS grab_imported_at,
        gr.imported_files AS grab_imported_files
   FROM wants w
   LEFT JOIN users u ON u.id = w.created_by
@@ -590,6 +591,7 @@ type ListWantsRow struct {
 	GrabProgress      *float32
 	GrabImportState   *string
 	GrabImportReason  *string
+	GrabEndDetail     *string
 	GrabImportedAt    pgtype.Timestamptz
 	GrabImportedFiles *int32
 }
@@ -636,6 +638,7 @@ func (q *Queries) ListWants(ctx context.Context, arg ListWantsParams) ([]ListWan
 			&i.GrabProgress,
 			&i.GrabImportState,
 			&i.GrabImportReason,
+			&i.GrabEndDetail,
 			&i.GrabImportedAt,
 			&i.GrabImportedFiles,
 		); err != nil {