feat: search and grab — music release names, a quality ladder, a paced search schedule and one live grab per want (M502 #5521)

- internal/release: reads a release name (format, bitrate, bit depth and
  sample rate, source, year, video, discography) and judges it against the
  album wanted: the artist and title must be in it; video rips,
  discographies, other versions (drumless, instrumental, karaoke, remix,
  live unless the album is live…) and singles or EPs for an album are
  refused. Quality tiers on Lidarr's ladder; a .torrent's file list is read
  for format, video files and a track count short of the album.
- internal/acquire: fan-out across every search source with a narrowed
  search kept, a process-wide pacer per source, every candidate judged and
  kept with its reasons, and the grab: one live grab per want, tie-broken
  (a person's grab beats the schedule's; a better release replaces a worse
  one unless it is nearly done). Each download lands in its own folder
  under the client's downloads folder.
- internal/wanted: the search schedule, every ten minutes, never-searched
  first, then requests, missing files and followed artists, taking the
  best release when auto-grab is on (the default).
- Migration 0082: acquisition_settings (auto-grab, interval, allowed
  qualities seeded from Lidarr's "Any"), want search columns,
  want_candidates, grabs, release_blocks.
- Web: the Wanted page shows each want's last search, a Search button and
  every release found with its verdict (Grab, Grab anyway, Never this one,
  Allow again). Integrations gains "Searching and grabbing".

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

web/src/lib/components/SearchSettingsCard.svelte

@@ -0,0 +1,162 @@
+<script lang="ts">
+  import { useQueryClient } from '@tanstack/svelte-query';
+  import { createSearchSettingsQuery, putSearchSettings } from '#lib/api/wanted.js';
+  import { qk } from '#lib/api/queries.js';
+  import { errMessage } from '#lib/api/errors.js';
+  import { pushToast } from '#lib/stores/toast.svelte.js';
+  import { relativeTime } from '#lib/utils/relativeTime.js';
+  import type { SearchSettings } from '#lib/api/types.js';
+
+  // Searching and grabbing (M502 #5521): how often each want is searched
+  // for, whether the best release is taken without asking, and which
+  // qualities are taken at all. The schedule wakes every ten minutes and
+  // keeps to each indexer's searches-per-hour.
+
+  const client = useQueryClient();
+  const store = createSearchSettingsQuery();
+  const query = $derived($store);
+
+  type Form = { auto_grab: boolean; search_interval_hours: number; allowed: string[] };
+
+  // The form is the server's settings until edited; saved holds what a save
+  // returned until the query catches up.
+  let saved = $state<SearchSettings | null>(null);
+  let edited = $state<Form | null>(null);
+  let saving = $state(false);
+  const base = $derived(saved ?? query.data ?? null);
+  const form = $derived<Form | null>(edited ?? (base ? fromSettings(base) : null));
+
+  function fromSettings(s: SearchSettings): Form {
+    return { auto_grab: s.auto_grab, search_interval_hours: s.search_interval_hours, allowed: [...s.allowed_qualities] };
+  }
+
+  const dirty = $derived(!!edited && !!base && JSON.stringify(edited) !== JSON.stringify(fromSettings(base)));
+
+  function edit(change: Partial<Form>) {
+    if (form) edited = { ...form, ...change };
+  }
+
+  function toggle(tier: string) {
+    if (!form) return;
+    edit({ allowed: form.allowed.includes(tier) ? form.allowed.filter((t) => t !== tier) : [...form.allowed, tier] });
+  }
+
+  async function save() {
+    if (!form) return;
+    saving = true;
+    try {
+      saved = await putSearchSettings({
+        auto_grab: form.auto_grab,
+        search_interval_hours: Number(form.search_interval_hours),
+        allowed_qualities: form.allowed
+      });
+      edited = null;
+      await client.invalidateQueries({ queryKey: qk.searchSettings() });
+      pushToast('Search settings saved. The next pass uses them.');
+    } catch (e) {
+      pushToast(errMessage(e), 'error');
+    } finally {
+      saving = false;
+    }
+  }
+
+  function lastPass(s: SearchSettings): string {
+    const p = s.last_pass;
+    if (!s.last_pass_at) return 'The schedule hasn’t run yet.';
+    const when = `Last pass ${relativeTime(s.last_pass_at)}`;
+    if (p.off) return `${when}: the schedule is off.`;
+    if (p.unconfigured) return `${when}: no indexer is set up, so nothing was searched.`;
+    if (p.error) return `${when} failed: ${p.error}`;
+    if (!p.looked) return `${when}: nothing was due.`;
+    let said = `${when}: searched ${p.looked}, took ${p.grabbed ?? 0}, ${p.waiting ?? 0} waiting for you, ${p.nothing ?? 0} with nothing found`;
+    if (p.failed) said += `, ${p.failed} failed`;
+    said += '.';
+    if (p.paced) said += ' It stopped to keep to your indexers’ searches per hour; the rest wait for the next pass.';
+    return said;
+  }
+</script>
+
+<section class="space-y-4 rounded-xl border border-border bg-surface p-5" data-testid="search-settings-card">
+  <div>
+    <h3 class="font-display text-lg font-medium text-text-primary">Searching and grabbing</h3>
+    <p class="mt-1 text-sm text-text-secondary">
+      Minstrel searches your indexers for each album on the
+      <a href="/admin/wanted" class="text-accent-fg hover:underline">wanted list</a>, judges every
+      release it finds, and hands the best one to your download client. Each album's releases and
+      the reason for every verdict are on the Wanted page.
+    </p>
+  </div>
+
+  {#if query.isPending}
+    <p class="text-sm text-text-secondary">Loading…</p>
+  {:else if query.isError || !form || !query.data}
+    <p class="text-sm text-action-destructive">Couldn't load the search settings.</p>
+  {:else}
+    <label class="flex items-start gap-3">
+      <input
+        type="checkbox"
+        checked={form.auto_grab}
+        onchange={(e) => edit({ auto_grab: e.currentTarget.checked })}
+        class="mt-1"
+      />
+      <span>
+        <span class="text-sm text-text-primary">Take the best release without asking</span>
+        <span class="block text-xs text-text-secondary">
+          Off, a search only lists what it found, and you choose from the Wanted page.
+        </span>
+      </span>
+    </label>
+
+    <label class="block">
+      <span class="text-sm text-text-primary">Search each album again after</span>
+      <span class="block text-xs text-text-secondary">
+        Hours between searches for an album still wanted. 0 switches the schedule off; Search on the
+        Wanted page still works.
+      </span>
+      <span class="mt-1 flex items-center gap-2">
+        <input
+          type="number"
+          min="0"
+          max="720"
+          value={form.search_interval_hours}
+          oninput={(e) => edit({ search_interval_hours: Number(e.currentTarget.value) })}
+          class="w-24 rounded border border-border bg-background px-2 py-1 text-sm text-text-primary
+                 focus-visible:outline-solid focus-visible:outline-2 focus-visible:outline-accent"
+        />
+        <span class="text-sm text-text-secondary">hours</span>
+      </span>
+    </label>
+
+    <fieldset>
+      <legend class="text-sm text-text-primary">Qualities to take</legend>
+      <span class="block text-xs text-text-secondary">
+        The best of these is taken first. A release that names no format has its file list read to
+        find out.
+      </span>
+      <div class="mt-2 space-y-1.5">
+        {#each query.data.tiers as t (t.tier)}
+          <label class="flex items-start gap-2">
+            <input type="checkbox" checked={form.allowed.includes(t.tier)} onchange={() => toggle(t.tier)} class="mt-0.5" />
+            <span class="text-sm text-text-primary">
+              {t.label}
+              <span class="block text-xs text-text-secondary">{t.what}</span>
+            </span>
+          </label>
+        {/each}
+      </div>
+    </fieldset>
+
+    <p class="text-xs text-text-secondary" data-testid="last-pass">{lastPass(query.data)}</p>
+
+    <div class="flex justify-end">
+      <button
+        type="button"
+        onclick={save}
+        disabled={!dirty || saving || form.allowed.length === 0}
+        class="rounded-md bg-action-secondary px-4 py-2 text-sm text-action-fg hover:opacity-90 disabled:cursor-not-allowed disabled:opacity-50"
+      >
+        {saving ? 'Saving…' : 'Save'}
+      </button>
+    </div>
+  {/if}
+</section>