fix: address code review findings

- Add is_ignored=0 filter to GetUnnotifiedReleases query per spec section 4.4
  (notification lifecycle must exclude ignored releases)
- Add FK constraint on notifications_sent.rgid referencing external_releases(rgid)
  per spec schema definition
- Wrap migration application + recording in transactions for atomicity
- Add config.yaml to .gitignore to prevent accidental secret commits
- Pin Dockerfile base image to alpine:3.21 and add non-root appuser
- Add test TestGetUnnotifiedReleases_IgnoredExcluded

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

.gitea/workflows/docker-build.yml

@@ -1,99 +0,0 @@
-name: CI/CD
-
-on:
-  push:
-    branches: [ main, master ]
-    tags: [ 'v*' ]
-  pull_request:
-    branches: [ main, master ]
-
-env:
-  GO_VERSION: "1.25"
-  REGISTRY: gitea.mrixs.me
-  IMAGE_NAME: naviwatcher
-  # Using a fixed username since GITEA_REPOSITORY_OWNER may not be available
-  # Replace 'Mrixs' with your actual Gitea username
-  USERNAME: mrixs
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-go@v5
-        with:
-          go-version: ${{ env.GO_VERSION }}
-
-      - name: Cache Go modules
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/go/pkg/mod
-            ~/.cache/go-build
-          key: go-test-${{ runner.os }}-${{ hashFiles('go.sum') }}
-          restore-keys: |
-            go-test-${{ runner.os }}-
-
-      - name: Download Go modules
-        run: go mod download
-
-      - name: Run tests
-        run: go test ./... -v -race -cover
-
-  build:
-    runs-on: ubuntu-latest
-    needs: test
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-go@v5
-        with:
-          go-version: ${{ env.GO_VERSION }}
-
-      - name: Cache Go modules and build cache
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/go/pkg/mod
-            ~/.cache/go-build
-          key: go-build-${{ runner.os }}-${{ hashFiles('go.sum') }}
-          restore-keys: |
-            go-build-${{ runner.os }}-
-
-      - name: Download Go modules
-        run: go mod download
-
-      - name: Build binary
-        run: go build -o naviwatcher ./cmd/naviwatcher
-
-  docker:
-    runs-on: ubuntu-latest
-    needs: build
-    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master' || startsWith(github.ref, 'refs/tags/v')
-    permissions:
-      packages: write
-      contents: read
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login to Gitea Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ env.USERNAME }}
-          password: ${{ secrets.PACKAGES_TOKEN }}
-
-      - name: Build and push
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          tags: |
-            ${{ env.REGISTRY }}/${{ env.USERNAME }}/${{ env.IMAGE_NAME }}:latest
-            ${{ env.REGISTRY }}/${{ env.USERNAME }}/${{ env.IMAGE_NAME }}:${{ github.sha }}
-          cache-from: type=registry,ref=${{ env.REGISTRY }}/${{ env.USERNAME }}/${{ env.IMAGE_NAME }}:buildcache
-          cache-to: type=registry,ref=${{ env.REGISTRY }}/${{ env.USERNAME }}/${{ env.IMAGE_NAME }}:buildcache,mode=max

.gitignore

@@ -1,13 +1,8 @@
 .DS_Store
-/naviwatcher
+naviwatcher
 naviwatcher-linux
 naviwatcher-mac
 naviwatcher.exe
 config.yaml
 data/
 coverage.out
-navidrome_cov.out
-.serena/
-
-# Local runtime database
-cmd/naviwatcher/naviwatcher.db

CI-CD-GUIDE.md

@@ -1,70 +0,0 @@
-# CI/CD with Gitea Actions for NaviWatcher
-
-This repository uses Gitea Actions to automatically build and publish Docker images.
-
-## Workflow Overview
-
-The workflow (`.gitea/workflows/docker-build.yml`) performs the following steps:
-
-1. **Trigger Conditions**:
-   - Pushes to `main` or `master` branches
-   - Pull requests targeting `main` or `master`
-   - Pushes of version tags (e.g., `v1.0.0`, `v2.1.0`)
-
-2. **Job Steps**:
-   - Checkout repository code
-   - Set up Go environment (version 1.25)
-   - Run `go mod tidy` and `go mod verify`
-   - Execute unit tests with coverage
-   - Set up Docker Buildx for multi-platform builds
-   - Authenticate with container registry
-   - Extract metadata for image tagging
-   - Build and push Docker image to registry
-
-## Required Secrets
-
-To use this workflow, you need to configure the following secrets in your Gitea repository:
-
-1. **REGISTRY_USERNAME** - Username for your container registry
-2. **REGISTRY_PASSWORD** - Password or access token for your container registry
-3. **REGISTRY** - The registry URL (e.g., `docker.io`, `ghcr.io`, or your private registry)
-4. **IMAGE_NAME** - The name for your Docker image (e.g., `naviwatcher`)
-
-## Environment Variables
-
-The workflow uses these environment variables (can be configured in the workflow or repository settings):
-
-- `REGISTRY`: Container registry URL
-- `IMAGE_NAME`: Name of the Docker image
-
-## Customization
-
-To customize the workflow:
-
-1. **Change trigger branches**: Modify the `branches` filter in the `on` section
-2. **Adjust Go version**: Update the `go-version` in the setup-go step
-3. **Modify build arguments**: Add build-args to the docker/build-push-action if needed
-4. **Change registry**: Update the REGISTRY environment variable and corresponding secrets
-
-## Example Configuration
-
-For Docker Hub:
-- REGISTRY: `docker.io`
-- IMAGE_NAME: `yourusername/naviwatcher`
-
-For GitHub Container Registry:
-- REGISTRY: `ghcr.io`
-- IMAGE_NAME: `username/naviwatcher`
-
-For GitLab Container Registry:
-- REGISTRY: `registry.gitlab.com`
-- IMAGE_NAME: `group/project/naviwatcher`
-
-## Troubleshooting
-
-If builds fail:
-
-1. Check that all required secrets are set correctly
-2. Verify you have push permissions to the target registry
-3. Ensure Dockerfile is valid and builds locally
-4. Check the Actions tab in Gitea for detailed logs

CLAUDE.md

@@ -108,17 +108,12 @@ Based on the specification (docs/Specification.md), the application follows a mo
    - Implements the comparison algorithm (0.85 similarity threshold)
    - Handles removal of special characters, years, and bracketed keywords
    - Compares local albums vs. external discographies
-	   - Applies per-artist ignore_singles/ignore_compilations filters at scan time for immediate responsiveness to setting changes
-
-   Shared normalization lives in `internal/normalize` (`NormalizeString`, `NormalizeArtistName`) — this is the single source of truth for string normalization, reused by both `internal/musicbrainz` and `internal/scanner`. Do NOT add local copies of normalization logic elsewhere.
 
 4. **Database Layer** (`internal/database/` or similar)
    - SQLite 3 integration via github.com/mattn/go-sqlite3
-   - Subsonic API client via github.com/delucks/go-subsonic
    - Manages schema migrations
    - Handles tables:
      - `artist_settings`: Artist monitoring configuration
-     - `local_albums`: Navidrome albums synced via Subsonic API (id, artist_id, title)
      - `external_releases`: Cached MusicBrainz data
      - `notifications_sent`: Sent notification tracking
 
@@ -151,16 +146,6 @@ Based on the specification (docs/Specification.md), the application follows a mo
 - Write table-driven tests for complex logic
 - Use dependency injection for testability
 - Apply the specified fuzzy matching algorithm consistently
-- Centralize shared logic: Place reusable filtering, validation, or utility functions in dedicated files (e.g., internal/musicbrainz/filter.go) and import them across packages to ensure consistent behavior across cache-hit, cache-miss, and real-time paths
-
-### Execution Flow
-The application follows a sequential data pipeline:
-1. Sync artists from Navidrome (populate artist_settings)
-2. Sync discographies from MusicBrainz (populate external_releases with filtering)
-3. Sync albums from Navidrome (populate local_albums)
-4. Scan for missing releases using fuzzy matching (produces MissingRelease results)
-
-This flow is implemented in the `syncAndScan()` function in `cmd/naviwatcher/main.go`, which is called by the periodic sync loop and on startup.
 
 ## Configuration Reference
 See docs/Specification.md Section 7 for full config.yaml structure including:

README.md

@@ -13,21 +13,16 @@ NaviWatcher is an autonomous service daemon that monitors your Navidrome music c
 1. **Scans** your Navidrome library via Subsonic API to get the list of artists and albums.
 2. **Fetches** full artist discographies from MusicBrainz (using Release Groups to avoid duplicate editions).
 3. **Compares** local collection with external data using fuzzy matching (configurable threshold, default 0.85).
-4. **Syncs automatically** on a periodic loop (`sync.interval`, default 6h): Navidrome artist/album pull → lazy MusicBrainz ID resolution → discography cache → re-scan, so the dashboard and digests always reflect current state.
-5. **Notifies** you about missing albums/singles/EPs through daily Telegram digests and a web dashboard.
-
-### How It Works Now
-
-On startup NaviWatcher opens (or auto-migrates) a local SQLite database at `naviwatcher.db` in the working directory, performs one immediate sync+scan, then runs a ticker-driven periodic sync+scan goroutine until SIGTERM. The Web UI serves a basic-auth-protected dashboard; the Notifier runs a cron scheduler emitting a daily digest of newly-found missing releases (tracked via `notifications_sent`). The MusicBrainz ID for each artist is resolved lazily on first sync and cached on the `artist_settings` row.
+4. **Notifies** you about missing albums/singles/EPs through daily Telegram digests and a web dashboard.
 
 ### Features
 
 - **Subsonic API compatible** — works with Navidrome, Airsonic, Ampache, and other Subsonic-compatible servers.
 - **Fuzzy matching** — smart string normalization (ignores remastered/deluxe/anniversary editions, year suffixes, special characters).
-- **Per-artist filters** — opt out of Singles and Compilations per artist (via `artist_settings`); type filtering includes only Album/Single/EP primary types (plus release groups whose secondary types include Single/EP/Compilation).
+- **Configurable filters** — ignore bootlegs, singles, compilations, live albums, remixes, soundtracks per artist or globally.
 - **MusicBrainz caching** — 24-hour TTL cache to minimize API calls and respect rate limits (1 req/sec).
-- **Telegram notifications** — daily summary messages with links to the web UI, sent on the configured `telegram.cron_schedule`.
-- **Web dashboard** — browse missing albums, ignore releases, manage artist-specific settings, with an archive of ignored releases.
+- **Telegram notifications** — daily summary messages with links to the web UI.
+- **Web dashboard** — browse missing albums, ignore releases, manage artist-specific settings.
 - **Single binary deployment** — all HTML templates embedded via `//go:embed`.
 - **Docker support** — ready for `docker compose` deployment.
 
@@ -67,13 +62,6 @@ On startup NaviWatcher opens (or auto-migrates) a local SQLite database at `navi
 
 5. **Access the web UI** at `http://localhost:8080`
 
-> **Note (current status):** On startup the service opens a local SQLite database at
-> `naviwatcher.db` in the working directory (existing databases are auto-migrated), performs
-> one immediate sync+scan, then runs a periodic sync+scan loop (`sync.interval`, default 6h)
-> until shutdown. `musicbrainz.user_agent` is required and validated at startup. The Web UI
-> (basic-auth protected) and Telegram notifier (cron-scheduled) are wired in; set
-> `telegram.enabled` to activate digests.
-
 ### Configuration
 
 ```yaml
@@ -82,11 +70,6 @@ server:
   port: 8080
   username: "admin"
   password: "CHANGE_ME"
-  # Externally-reachable base URL for links in Telegram digests (e.g. behind a
-  # reverse proxy). If omitted, links are derived from host:port — but when host
-  # is 0.0.0.0 (the unspecified bind address) no link is emitted, since it is
-  # not reachable from outside the host.
-  public_url: "https://naviwatcher.example.com"
 
 navidrome:
   url: "http://localhost:4533"
@@ -105,10 +88,8 @@ telegram:
 
 scanner:
   fuzzy_threshold: 0.85
-
-# Periodic sync+scan loop frequency (Go duration, e.g. "6h", "30m"); defaults to 6h.
-sync:
-  interval: 6h
+  ignore_bootlegs: true
+  include_compilations: true
 ```
 
 See [docs/Specification.md](docs/Specification.md) for the full configuration reference and architecture details.
@@ -120,17 +101,10 @@ See [docs/Specification.md](docs/Specification.md) for the full configuration re
 | **Navidrome Client** | Subsonic API v1.16.1 communication (token-based auth) |
 | **MusicBrainz Provider** | Discography fetching with rate limiting and caching |
 | **Scanner Engine** | String normalization and fuzzy comparison |
-| **Database Layer** | SQLite persistence: `artist_settings`, `local_albums` (Navidrome sync), `external_releases` (MusicBrainz cache), `notifications_sent` |
+| **Database Layer** | SQLite persistence for settings, cache, and state |
 | **Notifier** | Scheduled Telegram notifications |
 | **Web UI** | Dashboard for browsing and managing missing releases |
 
-### Implementation Status
-
-- **Scanner Engine** — implemented. The missing-release detection core is complete: string normalization lives in `internal/normalize`, similarity scoring and the diff engine (`FindMissingReleases`, `ScanArtist`, `ScanAll`) in `internal/scanner`. It uses the configurable `scanner.fuzzy_threshold` (default 0.85), normalizes titles (ignoring `(Remastered)`/year/special-char variants), and skips releases marked ignored.
-- **Sync pipeline** — implemented. `SyncAll` pulls artists/albums from Navidrome into the DB, resolves each artist's MusicBrainz ID lazily (cached on `artist_settings.mbid`), syncs the MusicBrainz discography, then re-runs the scanner. Wired into `main.run()` as an immediate + periodic (`sync.interval`) loop.
-- **Notifier** — implemented. A `Sender` interface with a Telegram implementation, `FormatDigest` for daily summaries, and a cron scheduler honoring `telegram.cron_schedule` (no-op when `enabled=false`); sent-tracking via `notifications_sent`.
-- **Web UI** — implemented. Basic-auth-protected `net/http` server with `//go:embed` templates: dashboard with missing-release counts, artist detail with ignore actions, and an archive of ignored releases with restore.
-
 ### License
 
 [WTFPL](License.md) — Do What The Fuck You Want To Public License
@@ -146,21 +120,16 @@ NaviWatcher — это автономный сервис-демон для мо
 1. **Сканирует** библиотеку Navidrome через Subsonic API — получает список артистов и альбомов.
 2. **Загружает** полные дискографии артистов из MusicBrainz (использует Release Groups, чтобы избежать дубликатов изданий).
 3. **Сравнивает** локальную коллекцию с внешними данными через нечёткое сравнение строк (настраиваемый порог, по умолчанию 0.85).
-4. **Синхронизируется автоматически** по периодическому циклу (`sync.interval`, по умолчанию 6h): выгрузка артистов/альбомов из Navidrome → ленивое разрешение MusicBrainz ID → кэш дискографии → повторное сканирование, чтобы панель и дайджесты всегда отражали текущее состояние.
-5. **Уведомляет** об отсутствующих альбомах/синглах/EP через ежедневные дайджесты в Telegram и веб-панель.
-
-### Как это работает сейчас
-
-При запуске NaviWatcher открывает (или автомигрирует) локальную SQLite-БД `naviwatcher.db` в рабочей директории, выполняет одну немедленную синхронизацию+сканирование, затем запускает управляемый тикером периодический цикл до получения SIGTERM. Веб-интерфейс — это панель под basic-auth; нотификатор запускает cron-планировщик, отправляющий ежедневный дайджест новых отсутствующих релизов (отслеживается через `notifications_sent`). MusicBrainz ID каждого артиста разрешается лениво при первой синхронизации и кэшируется в строке `artist_settings`.
+4. **Уведомляет** об отсутствующих альбомах/синглах/EP через ежедневные дайджесты в Telegram и веб-панель.
 
 ### Возможности
 
 - **Совместим с Subsonic API** — работает с Navidrome, Airsonic, Ampache и другими Subsonic-совместимыми серверами.
 - **Нечёткое сравнение** — умная нормализация строк (игнорирует ремастеры, deluxe/anniversary-издания, год в скобках, спецсимволы).
-- **Фильтры по артистам** — отключение синглов и компиляций для конкретного артиста (через `artist_settings`); фильтрация по типам включает только основные типы Album/Single/EP (а также группы релизов, чьи вторичные типы содержат Single/EP/Compilation).
+- **Гибкие фильтры** — игнорирование бутлегов, синглов, компиляций, лайвов, ремиксаундов — глобально или для конкретного артиста.
 - **Кэширование MusicBrainz** — TTL 24 часа для минимизации запросов и соблюдения лимитов (1 запрос/сек).
-- **Уведомления в Telegram** — ежедневные сводки со ссылками на веб-интерфейс, отправляемые по расписанию `telegram.cron_schedule`.
-- **Веб-панель** — просмотр отсутствующих альбомов, игнорирование релизов, управление настройками артистов, архив проигнорированных релизов.
+- **Уведомления в Telegram** — ежедневные сводки со ссылками на веб-интерфейс.
+- **Веб-панель** — просмотр отсутствующих альбомов, игнорирование релизов, управление настройками артистов.
 - **Один бинарный файл** — все HTML-шаблоны встроены через `//go:embed`.
 - **Поддержка Docker** — готов к развёртыванию через `docker compose`.
 
@@ -208,10 +177,6 @@ server:
   port: 8080
   username: "admin"
   password: "CHANGE_ME"
-  # Внешний базовый URL для ссылок в дайджестах Telegram (напр. за обратным прокси).
-  # Если не задан, ссылки строятся из host:port — но при host 0.0.0.0 (несpecificированный
-  # адрес привязки) ссылка не генерируется, так как недоступна снаружи хоста.
-  public_url: "https://naviwatcher.example.com"
 
 navidrome:
   url: "http://localhost:4533"
@@ -230,10 +195,8 @@ telegram:
 
 scanner:
   fuzzy_threshold: 0.85
-
-# Частота периодического цикла синхронизации+сканирования (длительность Go, напр. "6h", "30m"); по умолчанию 6h.
-sync:
-  interval: 6h
+  ignore_bootlegs: true
+  include_compilations: true
 ```
 
 Полную справку по конфигурации и архитектуру см. в [docs/Specification.md](docs/Specification.md).
@@ -245,17 +208,10 @@ sync:
 | **Navidrome Client** | Взаимодействие с Subsonic API v1.16.1 (токенная аутентификация) |
 | **MusicBrainz Provider** | Загрузка дискографий с кэшированием и rate limiting |
 | **Scanner Engine** | Нормализация строк и нечёткое сравнение |
-| **Database Layer** | SQLite: `artist_settings`, `local_albums` (синхронизация из Navidrome), `external_releases` (кэш MusicBrainz), `notifications_sent` |
+| **Database Layer** | Хранение настроек, кэша и состояния в SQLite |
 | **Notifier** | Планировщик уведомлений в Telegram |
 | **Web UI** | Панель управления отсутствющими релизами |
 
-### Статус реализации
-
-- **Scanner Engine** — реализован. Ядро поиска отсутствующих релизов готово: нормализация строк в `internal/normalize`, оценка схожести и движок сравнения (`FindMissingReleases`, `ScanArtist`, `ScanAll`) в `internal/scanner`. Используется настраиваемый `scanner.fuzzy_threshold` (по умолчанию 0.85), игнорируются варианты `(Remastered)`/год/спецсимволы, пропускаются отмеченные как игнорируемые.
-- **Sync pipeline** — реализован. `SyncAll` выгружает артистов/альбомы из Navidrome в БД, лениво разрешает MusicBrainz ID каждого артиста (кэшируется в `artist_settings.mbid`), синхронизирует дискографию MusicBrainz, затем повторно запускает сканер. Подключён в `main.run()` как немедленный + периодический (`sync.interval`) цикл.
-- **Notifier** — реализован. Интерфейс `Sender` с Telegram-реализацией, `FormatDigest` для ежедневных сводок и cron-планировщик по `telegram.cron_schedule` (no-op при `enabled=false`); отслеживание отправок через `notifications_sent`.
-- **Web UI** — реализован. Защищённый basic-auth `net/http` сервер с `//go:embed` шаблонами: панель со счётчиками отсутствующих релизов, страница артиста с действиями игнорирования и архив проигнорированных релизов с восстановлением.
-
 ### Лицензия
 
 [WTFPL](License.md) — Do What The Fuck You Want To Public License

cmd/naviwatcher/datastore_smoke_test.go

@@ -1,159 +0,0 @@
-package main
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"naviwatcher/internal/config"
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/notifier"
-	"naviwatcher/internal/scanner"
-	"naviwatcher/internal/web"
-)
-
-// TestDataFlowSmoke seeds an in-memory DB with a monitored artist, one local
-// album, and a missing external release, then exercises the full
-// scan -> notify -> web pipeline end to end:
-//   - ScanAll reports the missing release
-//   - NotifyOnce (with a stub sender) sends exactly the missing release and
-//     marks it as sent, so a second run reports nothing
-//   - The Web UI dashboard requires auth and renders the artist + missing count,
-//     and the artist detail page renders the missing release
-//
-// This is the acceptance smoke check for Task 9.
-func TestDataFlowSmoke(t *testing.T) {
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("open :memory: db: %v", err)
-	}
-	defer db.Close()
-
-	ctx := context.Background()
-
-	// Seed: one monitored artist with one local album ...
-	if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-		ID:        "ar1",
-		Name:      "Pink Floyd",
-		MBID:      "abcdef",
-		Monitored: true,
-	}); err != nil {
-		t.Fatalf("seed artist: %v", err)
-	}
-	if err := database.SaveLocalAlbum(db, &database.LocalAlbum{
-		ID:       "al1",
-		ArtistID: "ar1",
-		Title:    "The Wall",
-	}); err != nil {
-		t.Fatalf("seed local album: %v", err)
-	}
-	// ... and a missing external release (not present locally).
-	if err := database.SaveExternalRelease(db, &database.ExternalRelease{
-		RGID:        "rg-missing",
-		ArtistID:    "ar1",
-		Title:       "Animals",
-		Type:        "Album",
-		ReleaseDate: "1977-01-01",
-	}); err != nil {
-		t.Fatalf("seed external release: %v", err)
-	}
-
-	// 1) ScanAll should surface exactly the missing release.
-	missing, err := scanner.ScanAll(ctx, db, 0.85)
-	if err != nil {
-		t.Fatalf("ScanAll: %v", err)
-	}
-	if len(missing) != 1 {
-		t.Fatalf("expected 1 missing release, got %d", len(missing))
-	}
-	if missing[0].RGID != "rg-missing" || missing[0].Title != "Animals" {
-		t.Fatalf("unexpected missing release: %+v", missing[0])
-	}
-
-	// 2) Notifier: stub sender, first run notifies 1, second run notifies 0.
-	var sent []string
-	stub := stubSender{onSend: func(msg string) error {
-		sent = append(sent, msg)
-		return nil
-	}}
-	tgCfg := config.TelegramConfig{Enabled: true}
-
-	n1, err := notifier.NotifyOnce(ctx, db, stub, tgCfg, "http://localhost:8080", 0.85)
-	if err != nil {
-		t.Fatalf("NotifyOnce #1: %v", err)
-	}
-	if n1 != 1 {
-		t.Fatalf("expected NotifyOnce to send 1, got %d", n1)
-	}
-	if len(sent) != 1 || !strings.Contains(sent[0], "Animals") {
-		t.Fatalf("digest missing expected content: %v", sent)
-	}
-
-	n2, err := notifier.NotifyOnce(ctx, db, stub, tgCfg, "http://localhost:8080", 0.85)
-	if err != nil {
-		t.Fatalf("NotifyOnce #2: %v", err)
-	}
-	if n2 != 0 {
-		t.Fatalf("expected second NotifyOnce to send 0 (already sent), got %d", n2)
-	}
-
-	// 3) Web UI: dashboard requires basic auth and renders the artist.
-	srvCfg := &config.ServerConfig{
-		Host:     "localhost",
-		Port:     0,
-		Username: "admin",
-		Password: "secret",
-	}
-	srv := web.NewServer(srvCfg, db, "http://localhost:8080", 0)
-
-	// Unauthenticated -> 401.
-	rec := httptest.NewRecorder()
-	req := httptest.NewRequest(http.MethodGet, "/", nil)
-	srv.Handler().ServeHTTP(rec, req)
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("expected 401 for unauthenticated dashboard, got %d", rec.Code)
-	}
-
-	// Authenticated -> 200 with the artist name and missing count.
-	rec = httptest.NewRecorder()
-	req = httptest.NewRequest(http.MethodGet, "/", nil)
-	req.SetBasicAuth("admin", "secret")
-	srv.Handler().ServeHTTP(rec, req)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200 for authenticated dashboard, got %d", rec.Code)
-	}
-	body := rec.Body.String()
-	if !strings.Contains(body, "Pink Floyd") {
-		t.Fatalf("dashboard did not render artist name; body head:\n%s", body[:min(400, len(body))])
-	}
-
-	// Artist detail page renders the missing release.
-	rec = httptest.NewRecorder()
-	req = httptest.NewRequest(http.MethodGet, "/artist/ar1", nil)
-	req.SetBasicAuth("admin", "secret")
-	srv.Handler().ServeHTTP(rec, req)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200 for artist page, got %d", rec.Code)
-	}
-	if !strings.Contains(rec.Body.String(), "Animals") {
-		t.Fatalf("artist page did not render missing release 'Animals'")
-	}
-}
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}
-
-// stubSender is a test double for notifier.Sender.
-type stubSender struct {
-	onSend func(message string) error
-}
-
-func (s stubSender) Send(_ context.Context, message string) error {
-	return s.onSend(message)
-}

cmd/naviwatcher/fuzzy_smoke_test.go

@@ -1,36 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"github.com/lithammer/fuzzysearch/fuzzy"
-
-	"naviwatcher/internal/scanner"
-)
-
-// TestFuzzySmoke verifies the fuzzysearch dependency and the Levenshtein-based
-// similarity primitive that the scanner engine actually uses (scanner.Similarity
-// delegates to fuzzy.LevenshteinDistance). This guards against the library
-// changing the distance semantics the engine relies on.
-func TestFuzzySmoke(t *testing.T) {
-	// Identical strings: zero edit distance.
-	if d := fuzzy.LevenshteinDistance("the wall", "the wall"); d != 0 {
-		t.Errorf("expected LevenshteinDistance of identical strings to be 0, got %d", d)
-	}
-
-	// A small edit (remaster suffix) is closer than a wholly different title.
-	near := fuzzy.LevenshteinDistance("the wall", "the wall remastered")
-	far := fuzzy.LevenshteinDistance("the wall", "completely different album")
-	if near >= far {
-		t.Errorf("expected near match distance (%d) < far match distance (%d)", near, far)
-	}
-
-	// The scanner's similarity score should report the near match as more
-	// similar than the far one, and the identical pair as a perfect match.
-	if s := scanner.Similarity("the wall", "the wall"); s != 1.0 {
-		t.Errorf("expected Similarity of identical strings to be 1.0, got %f", s)
-	}
-	if scanner.Similarity("the wall", "the wall remastered") <= scanner.Similarity("the wall", "completely different album") {
-		t.Error("expected near match to score higher than far match")
-	}
-}

cmd/naviwatcher/main.go

@@ -3,41 +3,14 @@ package main
 import (
 	"context"
 	"flag"
-	"fmt"
 	"log"
 	"os"
 	"os/signal"
 	"syscall"
-	"time"
 
 	"naviwatcher/internal/config"
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/musicbrainz"
-	"naviwatcher/internal/navidrome"
-	"naviwatcher/internal/notifier"
-	"naviwatcher/internal/scanner"
-	"naviwatcher/internal/web"
 )
 
-// App holds all application dependencies for clean shutdown and testability.
-type App struct {
-	cfg      *config.Config
-	db       *database.DB
-	mbClient *musicbrainz.MusicBrainzClient
-	ndClient *navidrome.NavidromeClient
-	web      *web.Server
-	sender   notifier.Sender
-
-	// syncFn, when non-nil, replaces the real syncAndScan call in
-	// startPeriodicSync so tests can observe the loop without live clients.
-	syncFn func(ctx context.Context) error
-}
-
-// navidromeClientFactory constructs the Navidrome client. It is a package-level
-// variable (not a direct call to navidrome.NewClient) so tests can inject a stub
-// without requiring a live Navidrome server for authentication.
-var navidromeClientFactory = navidrome.NewClient
-
 const defaultConfigPath = "config.yaml"
 
 func main() {
@@ -65,213 +38,17 @@ func main() {
 		cancel()
 	}()
 
-	app, err := NewApp(ctx, cfg, "naviwatcher.db")
-	if err != nil {
-		log.Fatalf("Failed to initialize application: %v", err)
-	}
-	defer app.Close()
-
-	if err := app.run(ctx); err != nil {
+	if err := run(ctx, cfg); err != nil {
 		log.Fatalf("Application error: %v", err)
 	}
 
 	log.Println("NaviWatcher stopped.")
 }
 
-// NewApp initializes all application components: config, database, and MusicBrainz client.
-// dbPath is the SQLite database path (use ":memory:" for tests).
-func NewApp(ctx context.Context, cfg *config.Config, dbPath string) (*App, error) {
-	// Initialize database.
-	db, err := database.New(dbPath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to initialize database: %w", err)
-	}
-
-	// Initialize MusicBrainz client with rate limiting.
-	mbClient := musicbrainz.NewClient(cfg.MusicBrainz)
-
-	log.Printf("MusicBrainz client initialized (user-agent: %s)", cfg.MusicBrainz.UserAgent)
-
-	// Initialize Navidrome client (authenticates immediately; error if auth fails).
-	ndClient, err := navidromeClientFactory(cfg.Navidrome)
-	if err != nil {
-		return nil, fmt.Errorf("failed to initialize navidrome client: %w", err)
-	}
-
-	// Build the Web UI dashboard server (not started until run).
-	webServer := web.NewServerWithConfig(cfg, db)
-
-	// Build the notifier sender. A nil sender is fine when Telegram is disabled;
-	// the scheduler is no-op-safe and the web UI needs no sender.
-	var sender notifier.Sender
-	if cfg.Telegram.Enabled {
-		sender = notifier.NewTelegramSender(cfg.Telegram)
-	}
-
-	return &App{
-		cfg:      cfg,
-		db:       db,
-		mbClient: mbClient,
-		ndClient: ndClient,
-		web:      webServer,
-		sender:   sender,
-	}, nil
-}
-
-// Close cleans up all application resources in reverse order of initialization.
-func (a *App) Close() {
-	if a.mbClient != nil {
-		a.mbClient.Close()
-	}
-	if a.db != nil {
-		if err := a.db.Close(); err != nil {
-			log.Printf("Error closing database: %v", err)
-		}
-	}
-}
-
-func (a *App) run(ctx context.Context) error {
-	// Start the Web UI dashboard FIRST, in its own goroutine, so the dashboard
-	// accepts connections immediately. The initial sync below is throttled by
-	// the MusicBrainz 1 req/s limit and can take many minutes on a large
-	// library (worst case: a fresh DB where every artist needs MBID
-	// resolution) — exactly when an operator is most likely watching. Starting
-	// the server first means the dashboard is reachable (serving cached data)
-	// during that window instead of refusing connections. It serves until ctx
-	// is cancelled, then shuts down gracefully.
-	if a.web != nil {
-		go func() {
-			if err := a.web.Start(ctx); err != nil {
-				if ctx.Err() != nil {
-					return
-				}
-				log.Printf("Web UI server stopped with error: %v", err)
-			}
-		}()
-	}
-
-	// Start the Telegram notifier scheduler. It is no-op-safe when Telegram is
-	// disabled (sender nil / enabled false), so always calling it is safe.
-	a.startNotifier(ctx)
-
-	// Kick off the periodic sync+scan loop. It runs an immediate first sync
-	// (governed by the same overlap guard as periodic ticks) so the service
-	// produces results without waiting a full interval, without racing a
-	// concurrent tick over the shared DB and rate-limited MusicBrainz client.
-	a.startPeriodicSync(ctx)
-
+func run(ctx context.Context, cfg *config.Config) error {
+	// Main application loop — blocks until context is cancelled.
+	// Business logic will be added in future tasks.
 	<-ctx.Done()
+
 	return nil
 }
-
-// doSync runs the sync pipeline, using the injected syncFn when present (tests)
-// or the real syncAndScan otherwise.
-func (a *App) doSync(ctx context.Context) error {
-	if a.syncFn != nil {
-		return a.syncFn(ctx)
-	}
-	return a.syncAndScan(ctx)
-}
-
-// syncAndScan runs the full data pipeline once: Navidrome artist sync, the
-// MusicBrainz discography pipeline (SyncAll), then the scanner over the
-// now-populated DB. It logs results and observes ctx cancellation.
-func (a *App) syncAndScan(ctx context.Context) error {
-	if err := navidrome.SyncArtists(ctx, a.ndClient, a.db); err != nil {
-		return fmt.Errorf("sync artists: %w", err)
-	}
-
-	discography := musicbrainz.NewDiscographySyncer(a.mbClient)
-	albums := musicbrainz.NewAlbumSyncer(func(ctx context.Context, db *database.DB) error {
-		return navidrome.SyncAlbums(ctx, a.ndClient, db)
-	})
-	if err := musicbrainz.SyncAll(ctx, a.db, a.mbClient, discography, albums, a.cfg.MusicBrainz.CacheTTL); err != nil {
-		return fmt.Errorf("sync all: %w", err)
-	}
-
-	missing, err := scanner.ScanAll(ctx, a.db, a.cfg.Scanner.FuzzyThreshold)
-	if err != nil {
-		return fmt.Errorf("scan all: %w", err)
-	}
-
-	log.Printf("Scan complete: %d missing release(s) across monitored artists", len(missing))
-	for _, m := range missing {
-		log.Printf("  missing: artist=%s rgid=%s title=%q", m.ArtistID, m.RGID, m.Title)
-	}
-	return nil
-}
-
-// startNotifier wires the Telegram digest scheduler. The scheduler is
-// no-op-safe (returns without starting when disabled or sender is nil), so it
-// is always safe to call. The base URL for dashboard links comes from the
-// server's configured public_url.
-func (a *App) startNotifier(ctx context.Context) {
-	if !a.cfg.Telegram.Enabled {
-		return
-	}
-	schedule, err := notifier.NewCronSchedule(a.cfg.Telegram.CronSchedule)
-	if err != nil {
-		log.Printf("Notifier schedule invalid (%q): %v; notifier disabled", a.cfg.Telegram.CronSchedule, err)
-		return
-	}
-	uiBaseURL := web.ResolveUIBaseURL(&a.cfg.Server)
-	notifier.StartScheduler(ctx, true, schedule, func(ctx context.Context) error {
-		_, err := notifier.NotifyOnce(ctx, a.db, a.sender, a.cfg.Telegram, uiBaseURL, a.cfg.Scanner.FuzzyThreshold)
-		return err
-	}, nil)
-}
-
-// startPeriodicSync runs syncAndScan on a ticker at cfg.Sync.Interval. It
-// blocks until ctx is cancelled, then returns cleanly. Each tick spawns a
-// goroutine so a slow sync does not block the ticker, but a new sync is
-// skipped while the previous one is still running (guarded by a done channel)
-// so syncs never overlap and contend for the shared DB and rate-limited
-// MusicBrainz client.
-func (a *App) startPeriodicSync(ctx context.Context) {
-	ticker := time.NewTicker(a.cfg.Sync.Interval)
-	defer ticker.Stop()
-
-	// free is a buffered token (capacity 1). A sync is in flight while the token
-	// is drained; the in-flight goroutine returns it when done so the next tick
-	// can start a new sync. While the token is held, ticks are skipped.
-	var free = make(chan struct{}, 1)
-	free <- struct{}{}
-
-	// launch starts a guarded sync if the slot is free, returning true when a
-	// sync was started and false when one is already in progress. The in-flight
-	// goroutine returns the token when done.
-	launch := func(label string) bool {
-		select {
-		case <-free:
-			go func() {
-				defer func() { free <- struct{}{} }()
-				if err := a.doSync(ctx); err != nil {
-					if ctx.Err() != nil {
-						return
-					}
-					log.Printf("%s sync+scan failed: %v", label, err)
-				}
-			}()
-			return true
-		default:
-			return false
-		}
-	}
-
-	// Immediate first sync (guarded), so the service produces results without
-	// waiting a full interval and without racing the first ticker fire.
-	launch("Initial")
-
-	for {
-		select {
-		case <-ctx.Done():
-			log.Println("Periodic sync stopped.")
-			return
-		case <-ticker.C:
-			if !launch("Periodic") {
-				// Previous sync still running; skip this tick.
-				log.Println("Skipping periodic sync: previous sync still in progress.")
-			}
-		}
-	}
-}

cmd/naviwatcher/main_test.go

@@ -1,191 +1,21 @@
 package main
 
 import (
-	"bytes"
 	"context"
-	"log"
 	"os"
 	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
 	"testing"
-	"time"
 
 	"naviwatcher/internal/config"
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/navidrome"
-	"naviwatcher/internal/scanner"
 )
 
-func TestAppRun_ScanLogsMissingReleases(t *testing.T) {
-	// Verify run() performs the sync+scan pipeline once (via the injected
-	// syncFn) and then blocks until ctx cancellation, returning nil. The
-	// injected syncFn performs the scan and logs the missing release, mirroring
-	// what syncAndScan does against live clients.
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	defer db.Close()
-
-	if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-		ID:        "artist-1",
-		Name:      "Pink Floyd",
-		Monitored: true,
-	}); err != nil {
-		t.Fatalf("seed artist: %v", err)
-	}
-	if err := database.SaveLocalAlbum(db, &database.LocalAlbum{
-		ID:       "l1",
-		ArtistID: "artist-1",
-		Title:    "The Wall",
-	}); err != nil {
-		t.Fatalf("seed local album: %v", err)
-	}
-	if err := database.SaveExternalRelease(db, &database.ExternalRelease{
-		RGID:     "rg2",
-		ArtistID: "artist-1",
-		Title:    "Animals",
-	}); err != nil {
-		t.Fatalf("seed external release: %v", err)
-	}
-
-	var buf bytes.Buffer
-	log.SetOutput(&buf)
-	defer log.SetOutput(os.Stderr)
-
-	app := &App{
-		cfg: &config.Config{
-			Scanner: config.ScannerConfig{FuzzyThreshold: 0.85},
-			Sync:    config.SyncConfig{Interval: time.Hour},
-		},
-		db: db,
-		syncFn: func(ctx context.Context) error {
-			missing, err := scanner.ScanAll(ctx, db, 0.85)
-			if err != nil {
-				return err
-			}
-			for _, m := range missing {
-				log.Printf("  missing: artist=%s rgid=%s title=%q", m.ArtistID, m.RGID, m.Title)
-			}
-			return nil
-		},
-	}
-
+func TestRun_GracefulShutdown(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// Run the (blocking) hook in a goroutine; cancel after it has had time to
-	// perform the scan so run() returns nil via the ctx.Done() path.
-	done := make(chan error, 1)
-	go func() { done <- app.run(ctx) }()
-
-	time.Sleep(50 * time.Millisecond)
 	cancel()
 
-	if err := <-done; err != nil {
-		t.Fatalf("app.run() returned error: %v", err)
-	}
-
-	// run() must have logged the missing release (Animals) for artist-1.
-	out := buf.String()
-	if !strings.Contains(out, "missing: artist=artist-1") || !strings.Contains(out, "Animals") {
-		t.Fatalf("app.run() did not log the expected missing release; log output:\n%s", out)
-	}
-}
-
-func TestStartPeriodicSync_FiresOnTick(t *testing.T) {
-	var calls int64
-	var wg sync.WaitGroup
-	wg.Add(2)
-
-	app := &App{
-		cfg: &config.Config{Sync: config.SyncConfig{Interval: 20 * time.Millisecond}},
-		syncFn: func(ctx context.Context) error {
-			atomic.AddInt64(&calls, 1)
-			wg.Done()
-			return nil
-		},
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	go app.startPeriodicSync(ctx)
-
-	if !waitWG(&wg, 2*time.Second) {
-		t.Fatal("expected syncFn to be called at least twice within timeout")
-	}
-
-	if got := atomic.LoadInt64(&calls); got < 2 {
-		t.Errorf("expected at least 2 sync calls, got %d", got)
-	}
-
-	cancel()
-}
-
-func TestStartPeriodicSync_CancelsCleanly(t *testing.T) {
-	var calls int64
-	app := &App{
-		cfg: &config.Config{Sync: config.SyncConfig{Interval: time.Hour}},
-		syncFn: func(ctx context.Context) error {
-			atomic.AddInt64(&calls, 1)
-			return nil
-		},
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	done := make(chan struct{})
-
-	go func() {
-		app.startPeriodicSync(ctx)
-		close(done)
-	}()
-
-	// With a 1h interval the ticker never fires on its own; cancel should
-	// return promptly. The loop does run one immediate (guarded) sync at
-	// startup, so depending on scheduling calls may be 0 (cancel won the race)
-	// or 1 (immediate sync ran) — but never more, since no tick can fire in 1h.
-	cancel()
-
-	select {
-	case <-done:
-		// clean exit
-	case <-time.After(2 * time.Second):
-		t.Fatal("startPeriodicSync did not exit after ctx cancellation")
-	}
-
-	if got := atomic.LoadInt64(&calls); got > 1 {
-		t.Errorf("expected at most 1 (immediate) sync call with 1h interval, got %d", got)
-	}
-}
-
-func TestDoSync_UsesInjectedSyncFn(t *testing.T) {
-	// Verify doSync prefers an injected syncFn when present (so the periodic
-	// loop and immediate run can be driven by tests without live clients),
-	// and falls back to the real syncAndScan otherwise.
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	defer db.Close()
-
-	var called int32
-	app := &App{
-		cfg: &config.Config{Sync: config.SyncConfig{Interval: time.Hour}},
-		db:  db,
-		syncFn: func(ctx context.Context) error {
-			atomic.StoreInt32(&called, 1)
-			return nil
-		},
-	}
-
-	if err := app.doSync(context.Background()); err != nil {
-		t.Fatalf("doSync returned error: %v", err)
-	}
-	if atomic.LoadInt32(&called) != 1 {
-		t.Fatal("expected injected syncFn to be called")
+	cfg := &config.Config{}
+	if err := run(ctx, cfg); err != nil {
+		t.Fatalf("run returned error: %v", err)
 	}
 }
 
@@ -224,161 +54,3 @@ musicbrainz:
 		t.Errorf("expected navidrome url http://localhost:4533, got %q", cfg.Navidrome.URL)
 	}
 }
-
-func TestNewApp_CreatesMusicBrainzClient(t *testing.T) {
-	// Verify that NewApp initializes the MusicBrainz client from config.
-	cfg := &config.Config{
-		Server: config.ServerConfig{
-			Host: "127.0.0.1",
-			Port: 9090,
-		},
-		Navidrome: config.NavidromeConfig{
-			URL:      "http://localhost:4533",
-			User:     "test",
-			Password: "test",
-		},
-		MusicBrainz: config.MusicBrainzConfig{
-			UserAgent: "NaviWatcher/1.0 ( test@example.com )",
-		},
-	}
-
-	// Inject an unauthenticated Navidrome client so the test needs no live server.
-	prevFactory := navidromeClientFactory
-	navidromeClientFactory = func(c config.NavidromeConfig) (*navidrome.NavidromeClient, error) {
-		return navidrome.NewClientUnauthenticated(c), nil
-	}
-	defer func() { navidromeClientFactory = prevFactory }()
-
-	ctx := context.Background()
-	app, err := NewApp(ctx, cfg, ":memory:")
-	if err != nil {
-		t.Fatalf("NewApp returned error: %v", err)
-	}
-	defer app.Close()
-
-	if app.mbClient == nil {
-		t.Fatal("expected MusicBrainz client to be initialized, got nil")
-	}
-	if app.ndClient == nil {
-		t.Fatal("expected Navidrome client to be initialized, got nil")
-	}
-	if app.db == nil {
-		t.Fatal("expected database to be initialized, got nil")
-	}
-	if app.cfg != cfg {
-		t.Fatal("expected app.cfg to be the config passed to NewApp")
-	}
-}
-
-func TestNewApp_GracefulShutdown(t *testing.T) {
-	// Verify that App.Close() cleans up resources without error.
-	cfg := &config.Config{
-		Server: config.ServerConfig{
-			Host: "127.0.0.1",
-			Port: 9090,
-		},
-		Navidrome: config.NavidromeConfig{
-			URL:      "http://localhost:4533",
-			User:     "test",
-			Password: "test",
-		},
-		MusicBrainz: config.MusicBrainzConfig{
-			UserAgent: "NaviWatcher/1.0 ( test@example.com )",
-		},
-	}
-
-	prevFactory := navidromeClientFactory
-	navidromeClientFactory = func(c config.NavidromeConfig) (*navidrome.NavidromeClient, error) {
-		return navidrome.NewClientUnauthenticated(c), nil
-	}
-	defer func() { navidromeClientFactory = prevFactory }()
-
-	ctx := context.Background()
-	app, err := NewApp(ctx, cfg, ":memory:")
-	if err != nil {
-		t.Fatalf("NewApp returned error: %v", err)
-	}
-
-	// Close should not panic or return error.
-	app.Close()
-}
-
-func TestAppRun_GracefulShutdown(t *testing.T) {
-	// Verify that app.run() returns nil when context is cancelled.
-	cfg := &config.Config{
-		Server: config.ServerConfig{
-			Host: "127.0.0.1",
-			Port: 9090,
-		},
-		Navidrome: config.NavidromeConfig{
-			URL:      "http://localhost:4533",
-			User:     "test",
-			Password: "test",
-		},
-		MusicBrainz: config.MusicBrainzConfig{
-			UserAgent: "NaviWatcher/1.0 ( test@example.com )",
-		},
-		Sync: config.SyncConfig{Interval: time.Hour},
-	}
-
-	prevFactory := navidromeClientFactory
-	navidromeClientFactory = func(c config.NavidromeConfig) (*navidrome.NavidromeClient, error) {
-		return navidrome.NewClientUnauthenticated(c), nil
-	}
-	defer func() { navidromeClientFactory = prevFactory }()
-
-	ctx, cancel := context.WithCancel(context.Background())
-
-	app, err := NewApp(ctx, cfg, ":memory:")
-	if err != nil {
-		t.Fatalf("NewApp returned error: %v", err)
-	}
-	defer app.Close()
-
-	// Cancel the context to trigger shutdown.
-	cancel()
-
-	if err := app.run(ctx); err != nil {
-		t.Fatalf("app.run returned error: %v", err)
-	}
-}
-
-func TestMusicBrainzUserAgentValidation(t *testing.T) {
-	// Verify that config validation requires MusicBrainz.UserAgent to be set.
-	dir := t.TempDir()
-	path := filepath.Join(dir, "config.yaml")
-
-	yaml := `server:
-  host: "127.0.0.1"
-  port: 9090
-navidrome:
-  url: "http://localhost:4533"
-  user: "test"
-  password: "test"
-musicbrainz:
-  user_agent: ""
-`
-	if err := os.WriteFile(path, []byte(yaml), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	_, err := config.LoadConfig(path)
-	if err == nil {
-		t.Fatal("expected config validation error for empty musicbrainz.user_agent, got nil")
-	}
-}
-
-// waitWG waits for wg with a timeout; returns true if it completed in time.
-func waitWG(wg *sync.WaitGroup, timeout time.Duration) bool {
-	done := make(chan struct{})
-	go func() {
-		wg.Wait()
-		close(done)
-	}()
-	select {
-	case <-done:
-		return true
-	case <-time.After(timeout):
-		return false
-	}
-}

config.yaml.example

@@ -4,11 +4,6 @@ server:
   # Basic Auth for Web UI access
   username: "admin"
   password: "CHANGE_ME"
-  # Externally-reachable base URL for links in Telegram digests (e.g. behind a
-  # reverse proxy). If omitted, links are derived from host:port — but when host
-  # is 0.0.0.0 (the unspecified bind address) no link is emitted, since it is
-  # not reachable from outside the host.
-  public_url: "https://naviwatcher.example.com"
 
 navidrome:
   url: "http://localhost:4533"
@@ -27,10 +22,5 @@ telegram:
 
 scanner:
   fuzzy_threshold: 0.85
-
-# Periodic sync+scan pipeline: how often NaviWatcher pulls artists/albums from
-# Navidrome, resolves MusicBrainz discographies, and re-runs the scanner.
-# Accepts any duration Go's time.ParseDuration understands (e.g. "6h", "30m").
-# Defaults to 6h when omitted.
-sync:
-  interval: 6h
+  ignore_bootlegs: true
+  include_compilations: true

docs/FILTER_FLOW.md

@@ -1,74 +0,0 @@
-# Filter Flow Documentation
-
-This document explains how the `ignore_singles` and `ignore_compilations` settings propagate through the NaviWatcher system.
-
-## Overview
-
-The application implements a dual-path filtering approach to balance storage efficiency with real-time responsiveness to user preference changes:
-
-1. **MusicBrainz Sync Path (Store-time filtering)**:
-   - Applies filtering when caching release groups from the MusicBrainz API
-   - Stores only filtered results in the `external_releases` table
-   - Reduces database size by excluding unwanted release types upfront
-
-2. **Scanner Path (Read-time filtering)**:
-   - Applies filtering when retrieving cached data for comparison
-   - Ensures changes to `ignore_singles`/`ignore_compilations` take effect immediately
-   - Provides real-time responsiveness without waiting for cache expiry
-
-## Data Flow
-
-1. **Artist Settings Storage**:
-   - Navidrome artist sync populates the `artist_settings` table
-   - Stores `ignore_singles` and `ignore_compilations` boolean flags per artist
-
-2. **MusicBrainz Synchronization**:
-   - `SyncArtistDiscography` retrieves artist settings via `getArtistFilterOptions`
-   - Applies filtering using `ApplyTypeToggles` before storing in `external_releases`
-   - On cache hits, re-applies filter to ensure freshness of user preferences
-
-3. **Scanning Process**:
-   - `ScanArtist settings via `GetArtistSettings`
-   - Creates `TypeFilter` with current `ignore_singles`/`ignore_compilations` values
-   - Applies filter during `FindMissingReleases` via `filter.suppressed()` check
-   - Uses same `musicbrainz.ApplyTypeToggles` logic for consistency
-
-## Implementation Details
-
-### Shared Filtering Logic
-
-Both paths use the same underlying filtering logic:
-- `musicbrainz.ApplyTypeToggles` for ExternalRelease filtering
-- `musicbrainz.ApplyTypeTogglesToReleaseGroups` for ReleaseGroup filtering
-- Consistent criteria: 
-  - IgnoreSingles: Type == "Single" OR Type == "EP" OR SecondaryTypes contains "Single"/"EP"
-  - IgnoreCompilations: Type == "Compilation" OR SecondaryTypes contains "Compilation"
-
-### TypeFilter Structure
-
-```go
-type TypeFilter struct {
-	IgnoreSingles      bool
-	IgnoreCompilations bool
-}
-```
-
-### Filter Application
-
-- **MusicBrainz Path**: `ApplyTypeToggles(releases, FilterOptions{IgnoreSingles: s.IgnoreSingles, IgnoreCompilations: s.IgnoreCompilations})`
-- **Scanner Path**: `filter.suppressed(ext)` which internally uses the same logic
-
-## Benefits
-
-1. **Storage Efficiency**: Only desired release types are cached in the database
-2. **Immediate Responsiveness**: User preference changes take effect in real-time
-3. **Consistent Behavior**: Both code paths produce identical filtering results
-4. **Cache Efficiency**: Existing cached data remains useful when preferences change
-
-## Related Files
-
-- `internal/scanner/diff.go`: TypeFilter definition and suppressed() method
-- `internal/scanner/scan.go`: ScanArtist and ScanAll functions
-- `internal/musicbrainz/sync.go`: SyncArtistDiscography and getArtistFilterOptions
-- `internal/musicbrainz/filter.go`: ApplyTypeToggles and related filtering functions
-- `internal/database/artist_settings.go`: GetArtistSettings and GetAllArtistSettings

docs/Specification.md

@@ -7,11 +7,10 @@
 
 
 ## 2. Технологический стек
-*   **Язык программирования:** Go 1.25+
+*   **Язык программирования:** Go 1.21+
 *   **База данных:** SQLite 3 (для хранения кэша, настроек и состояний).
 *   **HTTP-сервер:** Стандартная библиотека Go (`net/http`) + `html/template`.
 *   **Внешние зависимости (библиотеки):**
-    *   `github.com/delucks/go-subsonic` — клиент Subsonic API (getArtists, getArtist, ping).
     *   `github.com/mattn/go-sqlite3` — драйвер базы данных.
     *   `github.com/lithammer/fuzzysearch` — библиотека для нечеткого сравнения строк.
     *   `gopkg.in/yaml.v3` — парсинг конфигурационных файлов.
@@ -75,32 +74,20 @@ NaviWatcher взаимодействует с Navidrome через **Subsonic AP
 
 ### Таблица `artist_settings`
 Хранит параметры мониторинга для каждого артиста из Navidrome.
-*   `id`: string (Navidrome artist ID — Primary Key)
+*   `id`: string (MBID или имя)
 *   `name`: string
-*   `mbid`: string (MusicBrainz Artist ID; разрешается лениво при первой синхронизации и кэшируется; миграция `008_add_mbid_to_artist_settings`). `NULL` до первого разрешения.
 *   `ignore_singles`: boolean (default: false)
 *   `ignore_compilations`: boolean (default: false)
 *   `monitored`: boolean (default: true)
-*   `last_synced`: datetime — время последней синхронизации дискографии; сигнал свежести кэша, чтобы пустые дискографии соблюдали TTL (миграция `009_add_last_synced_to_artist_settings`). `NULL` — ещё не синхронизировался.
 
 ### Таблица `external_releases`
 Кэш релизов, найденных во внешнем мире.
 *   `rgid`: string (MusicBrainz Release Group ID) — Primary Key.
 *   `artist_id`: string (FK)
 *   `title`: string
-*   `type`: string (album/single/ep/compilation)
+*   `type`: string (album/single/ep)
 *   `release_date`: string
 *   `is_ignored`: boolean (флаг скрытия из списка новинок)
-*   `cached_at`: datetime — время последней синхронизации/кэширования из MusicBrainz; используется для проверки TTL кэша (см. миграцию `005_add_cached_at_to_external_releases`). Значение `NULL` означает отсутствие актуального кэша.
-*   `secondary_types`: text — вторичные типы Release Group (Single/EP/Compilation и т.д.), через запятую; используются для фильтрации по типам наряду с первичным `type` (миграция `006_add_secondary_types_to_external_releases`).
-
-### Таблица `local_albums`
-Локальные альбомы, синхронизированные из Navidrome через Subsonic API.
-*   `id`: string — Subsonic album ID, Primary Key.
-*   `artist_id`: string — FK → `artist_settings.id`.
-*   `title`: string — название альбома.
-
-**Решение по хранению локальных альбомов:** Для локальных альбомов используется отдельная таблица `local_albums` (вариант 1 из трёх рассмотренных). Это обеспечивает чистое разделение ответственности: `external_releases` хранит данные MusicBrainz (Release Groups), а `local_albums` — данные Navidrome. Смешивание этих сущностей в одной таблице (через колонку `source` или флаг) усложнило бы запросы и фильтрацию, а также привело бы к неоднородности схемы (разные типы ID, разные наборы полей).
 
 ### Таблица `notifications_sent`
 *   `rgid`: string (FK)
@@ -131,9 +118,6 @@ server:
   # Basic Auth для доступа к веб-интерфейсу
   username: "admin"
   password: "password123"
-  # Внешний адрес веб-интерфейса для ссылок в Telegram-дайджестах.
-  # Если пусто, используется host:port (кроме 0.0.0.0 — тогда ссылка не формируется).
-  public_url: "https://naviwatcher.example.com"
 
 navidrome:
   url: "http://localhost:4533"
@@ -153,10 +137,8 @@ telegram:
 
 scanner:
   fuzzy_threshold: 0.85
-
-# Периодический цикл sync+scan (длительность Go, напр. "6h", "30m"); по умолчанию 6h
-sync:
-  interval: 6h
+  ignore_bootlegs: true
+  include_compilations: true
 ```
 
 

docs/plans/completed/2026-05-20-navidrome-client.md

@@ -1,179 +0,0 @@
-# Navidrome/Subsonic API Client
-
-## Overview
-Build the Navidrome client module that connects to a Navidrome server via the Subsonic API, fetches artist and album data, and syncs it into the local SQLite database. This is the first business logic module — it turns NaviWatcher from an empty skeleton into a service that can actually read your music library.
-
-**Problem it solves:** NaviWatcher needs to know what artists and albums exist in the user's Navidrome instance to later compare against MusicBrainz discographies. This module provides that data.
-
-**How it integrates:**
-- Depends on: `internal/config` (NavidromeConfig), `internal/database` (CRUD operations)
-- Will be consumed by: Plan 4 (Scanner engine — compares local albums vs MusicBrainz)
-- The `run()` function in `main.go` will later be expanded to initialize and trigger the sync
-
-## Context (from discovery)
-- **Files/components involved:**
-  - New: `internal/navidrome/client.go`, `internal/navidrome/client_test.go`, `internal/navidrome/sync.go`, `internal/navidrome/sync_test.go`
-  - Existing: `internal/config/config.go` (NavidromeConfig with URL, User, Password), `internal/database/` (ArtistSettings CRUD, full DB layer), `cmd/naviwatcher/main.go` (run() skeleton)
-- **Related patterns found:**
-  - Go module name: `naviwatcher`
-  - DB uses `database/sql` + `go-sqlite3` with WAL mode and foreign keys
-  - `ArtistSettings` struct: ID, Name, IgnoreSingles, IgnoreCompilations, Monitored
-  - Graceful shutdown via `context.Context` pattern in main.go
-- **Dependencies to add:** `github.com/delucks/go-subsonic` (Subsonic API client library — supports getArtists, getArtist, getAlbum, ping; tested on Navidrome)
-- **Auth method:** Subsonic token-based auth: `md5(password + salt)`, password never sent in plaintext
-- **Subsonic API version:** v1.16.1
-
-## Development Approach
-- **Testing approach:** Regular (code first, then tests)
-- Complete each task fully before moving to the next
-- Make small, focused changes
-- **CRITICAL: every task MUST include new/updated tests** for code changes in that task
-- **CRITICAL: all tests must pass before starting next task** — no exceptions
-- **CRITICAL: update this plan file when scope changes during implementation**
-- Run tests after each change
-
-## Testing Strategy
-- **Unit tests:** required for every task
-- Use `httptest.NewServer` to mock Subsonic API responses for client tests
-- Use in-memory SQLite (`:memory:`) for sync tests
-- Tests cover: success cases, API errors, malformed responses, empty libraries, context cancellation
-
-## Progress Tracking
-- Mark completed items with `[x]` immediately when done
-- Add newly discovered tasks with ➕ prefix
-- Document issues/blockers with ⚠️ prefix
-
-## What Goes Where
-- **Implementation Steps** (`[ ]` checkboxes): code changes, tests, documentation
-- **Post-Completion** (no checkboxes): manual testing against real Navidrome
-
-## Implementation Steps
-
-### Task 1: Add go-subsonic dependency and create client wrapper
-- [x] run `go get github.com/delucks/go-subsonic@latest`
-- [x] run `go mod tidy`
-- [x] create `internal/navidrome/client.go` with `NavidromeClient` struct wrapping `subsonic.Client`
-- [x] implement `NewClient(cfg config.NavidromeConfig) (*NavidromeClient, error)` constructor
-- [x] implement `Ping(ctx context.Context) error` — health check via Subsonic ping endpoint
-- [x] write tests: NewClient with valid config
-- [x] write tests: Ping success (mock HTTP server returning valid Subsonic response)
-- [x] write tests: Ping failure (server unreachable, invalid credentials, non-200 status)
-- [x] run tests — must pass before task 2
-
-### Task 2: Implement artist fetching
-- [x] in `internal/navidrome/client.go`, implement `GetArtists(ctx context.Context) ([]ArtistInfo, error)` — fetches all artists via `getArtists` endpoint
-- [x] define `ArtistInfo` struct with ID and Name fields (mapped from Subsonic response)
-- [x] write tests: GetArtists success with multiple artists (mock server)
-- [x] write tests: GetArtists empty library
-- [x] write tests: GetArtists API error handling
-- [x] run tests — must pass before task 3
-
-### Task 3: Implement album fetching per artist
-- [x] in `internal/navidrome/client.go`, implement `GetArtistAlbums(ctx context.Context, artistID string) ([]AlbumInfo, error)` — fetches albums via `getArtist` endpoint
-- [x] define `AlbumInfo` struct with ID, Name, ArtistID fields
-- [x] write tests: GetArtistAlbums success with multiple albums
-- [x] write tests: GetArtistAlbums artist with no albums
-- [x] write tests: GetArtistAlbums API error handling
-- [x] run tests — before task 4
-
-### Task 4: Implement sync — artists to local DB
-- [x] create `internal/navidrome/sync.go` with `SyncArtists(ctx context.Context, client *NavidromeClient, db *database.DB) error`
-- [x] implement sync logic: fetch all artists from Navidrome → upsert into `artist_settings` table (monitored=true by default)
-- [x] handle context cancellation gracefully
-- [x] create `internal/navidrome/sync_test.go`
-- [x] write tests: SyncArtists with empty Navidrome library
-- [x] write tests: SyncArtists with multiple artists (verify DB state after sync)
-- [x] write tests: SyncArtists idempotency (running twice doesn't duplicate)
-- [x] write tests: SyncArtists context cancellation
-- [x] run tests — must pass before task 5
-
-### Task 5: Implement sync — albums to local DB
-- [x] in `internal/navidrome/sync.go`, implement `SyncAlbums(ctx context.Context, client *NavidromeClient, db *database.DB) error`
-- [x] implement sync logic: for each monitored artist, fetch albums → store in `local_albums` table (new table, clean separation from `external_releases` which is for MusicBrainz data)
-- [x] **Schema decision:** Added `local_albums` table (id TEXT PK, artist_id TEXT FK→artist_settings.id, title TEXT) — clean separation of concerns (Option 1 from plan)
-- [x] handle context cancellation gracefully
-- [x] write tests: SyncAlbums for single artist with multiple albums
-- [x] write tests: SyncAlbums skips unmonitored artists
-- [x] write tests: SyncAlbums API error mid-sync (partial sync handling)
-- [x] run tests — must pass before task 6
-
-### Task 6: Verify acceptance criteria
-- [x] verify go-subsonic is in go.mod and go.sum
-- [x] verify Ping works against mock server
-- [x] verify GetArtists returns parsed artist list
-- [x] verify GetArtistAlbums returns parsed album list
-- [x] verify SyncArtists populates artist_settings table
-- [x] verify SyncAlbums populates album data
-- [x] run full test suite: `go test ./... -v` — all must pass
-- [x] run `go vet ./...` — no issues
-- [x] run `go fmt ./...` — no formatting issues
-- [x] verify test coverage for navidrome package (70%+)
-
-### Task 7: Update documentation
-- [x] update README.md with Navidrome setup instructions (creating service user) — already present in Quick Start; enhanced architecture table with table names
-- [x] document any schema changes made (e.g., new tables or columns) — added `local_albums` table docs to Specification.md Section 5
-- [x] document the `source` field decision for album storage — documented Option 1 (separate table) with rationale in Specification.md
-
-*Note: ralphex automatically moves completed plans to `docs/plans/completed/`*
-
-## Technical Details
-
-### Subsonic API Authentication
-The go-subsonic library handles token-based auth internally. The client constructor passes URL, user, and password — the library generates `md5(password + salt)` per request.
-
-### Expected Data Flow
-```
-Navidrome Server (Subsonic API)
-    │
-    ▼
-NavidromeClient (internal/navidrome/client.go)
-    │  - Ping()
-    │  - GetArtists() → []ArtistInfo
-    │  - GetArtistAlbums() → []AlbumInfo
-    ▼
-Sync (internal/navidrome/sync.go)
-    │  - SyncArtists() → artist_settings table
-    │  - SyncAlbums() → local_albums or external_releases table
-    ▼
-SQLite Database
-```
-
-### Mock Server Pattern for Tests
-```go
-// Create a test HTTP server that returns Subsonic XML responses
-server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-    w.Header().Set("Content-Type", "application/xml")
-    w.Write([]byte(`<subsonic-response status="ok" version="1.16.1">
-        <artists>
-            <index name="A">
-                <artist id="1" name="Artist One"/>
-                <artist id="2" name="Artist Two"/>
-            </index>
-        </artists>
-    </subsonic-response>`))
-}))
-defer server.Close()
-```
-
-### Schema Decision Needed (Task 5)
-The current `external_releases` table is designed for MusicBrainz data. Local albums from Navidrome need a home. Options:
-1. **Add `local_albums` table** — clean separation, but adds a table
-2. **Add `source` column to `external_releases`** — simpler, but mixes concerns
-3. **Reuse `external_releases` with a flag** — similar to option 2
-
-The implementation should pick one and document it. Option 1 (separate table) is recommended for clean separation of concerns.
-
-## Post-Completion
-*Items requiring manual intervention or external systems*
-
-**Manual verification:**
-- Set up a real Navidrome instance with test music library
-- Configure config.yaml with real credentials
-- Run the sync and verify artists/albums appear in the database
-- Check that unmonitored artists are skipped during album sync
-
-**Follow-up plans needed:**
-- Plan 3: MusicBrainz provider with rate limiting
-- Plan 4: Scanner engine with fuzzy matching (depends on Navidrome client + MusicBrainz)
-- Plan 5: Telegram notifier
-- Plan 6: Web UI

docs/plans/completed/2026-05-21-musicbrainz-provider.md

@@ -1,134 +0,0 @@
-# 2026-05-21-musicbrainz-provider
-
-## Overview
-Implement a MusicBrainz API provider with strict 1 request/second rate limiting, 24-hour caching of Release Group data, and filtering capabilities as per specification. The provider will fetch artist discographies from MusicBrainz, normalize the data, and store it in the external_releases table for use by the scanner engine.
-
-## Context (from discovery)
-- Files/components involved: internal/musicbrainz/ package (new), database schema updates, main.go integration
-- Related patterns found: Follows the internal/navidrome/ pattern with client.go, sync.go, and model separation
-- Dependencies identified: Will add golang.org/x/time/rate for rate limiting, use net/http for API calls
-
-## Development Approach
-- **Testing approach**: Regular (code first, then tests)
-- Complete each task fully before moving to the next
-- Make small, focused changes
-- **CRITICAL: every task MUST include new/updated tests** for code changes in that task
-  - tests are not optional - they are a required part of the checklist
-  - write unit tests for new functions/methods
-  - write unit tests for modified functions/methods
-  - add new test cases for new code paths
-  - update existing test cases if behavior changes
-  - tests cover both success and error scenarios
-- **CRITICAL: all tests must pass before starting next task** - no exceptions
-- **CRITICAL: update this plan file when scope changes during implementation**
-- Run tests after each change
-- Maintain backward compatibility
-
-## Testing Strategy
-- **Unit tests**: required for every task (see Development Approach above)
-- **E2E tests**: if project has UI-based e2e tests (Playwright, Cypress, etc.):
-  - UI changes → add/update e2e tests in same task as UI code
-  - Backend changes supporting UI → add/update e2e tests in same task
-  - Treat e2e tests with same rigor as unit tests (must pass before next task)
-  - Store e2e tests alongside unit tests (or in designated e2e directory)
-
-## Progress Tracking
-- Mark completed items with `[x]` immediately when done
-- Add newly discovered tasks with ➕ prefix
-- Document issues/blockers with ⚠️ prefix
-- Update plan if implementation deviates from original scope
-- Keep plan in sync with actual work done
-
-## What Goes Where
-- **Implementation Steps** (`[ ]` checkboxes): tasks achievable within this codebase - code changes, tests, documentation updates
-- **Post-Completion** (no checkboxes): items requiring external action - manual testing, changes in consuming projects, deployment configs, third-party verifications
-- **Checkbox placement**: Checkboxes belong only in Task sections (`### Task N:` or `### Iteration N:`). Do not put checkboxes in Success criteria, Overview, or Context — they cause extra loop iterations.
-
-## Implementation Steps
-
-### Task 1: Create MusicBrainz client and data models
-- [x] create `internal/musicbrainz/client.go` with MusicBrainzClient struct wrapping net/http.Client
-- [x] implement constructor taking config and rate limiter
-- [x] create `internal/musicbrainz/model.go` with structs for MusicBrainz API responses (ReleaseGroup, Artist, etc.)
-- [x] implement XML parsing functions for MusicBrainz responses
-- [x] write tests for XML parsing (success + error cases)
-- [x] write tests for client constructor and basic API call structure
-- [x] run tests - must pass before next task
-
-### Task 2: Implement rate limiting and caching layer
-- [x] add golang.org/x/time/rate dependency to go.mod
-- [x] implement rate limiter using golang.org/x/time/rate.NewLimiter(1, 1) for 1 req/sec
-- [x] create wrapper method for rate-limited HTTP GET requests
-- [x] implement caching check: query database for existing Release Group data within TTL
-- [x] write tests for rate limiting behavior (timing tests)
-- [x] write tests for cache hit/miss logic
-- [x] run tests - must pass before next task
-
-### Task 3: Implement MusicBrainz API endpoints and filtering
-- [x] implement GetArtistReleaseGroups(artistMBID string) method
-- [x] apply filters: exclude Bootleg/Promotion/Pseudo-Release status
-- [x] apply type filters: include Album/Single/EP/Compilation only
-- [x] implement per-artist type filtering hooks (placeholder for Web UI integration)
-- [x] normalize artist names and titles (remove special characters, years, brackets)
-- [x] write tests for filtering logic (table-driven test cases)
-- [x] write tests for normalization functions
-- [x] run tests - must pass before next task
-
-### Task 4: Implement database integration and sync orchestration
-- [x] create `internal/musicbrainz/sync.go` with SyncArtistDiscography function
-- [x] implement upsert logic: INSERT OR REPLACE into external_releases table
-- [x] add cached_at column to external_releases table via migration (done in Task 3 as migration 005)
-- [x] implement context.Context support for cancellation
-- [x] write tests for database upsert operations
-- [x] write integration tests with in-memory SQLite
-- [x] run tests - must pass before next task
-
-### Task 5: Wire up provider in application entry point
-- [x] update `cmd/naviwatcher/main.go` to initialize MusicBrainz client
-- [x] add MusicBrainz client to application context/dependencies
-- [x] ensure graceful shutdown includes closing HTTP client connections
-- [x] update config validation to ensure MusicBrainz.UserAgent is set
-- [x] write tests for main.go integration (startup/shutdown)
-- [x] run tests - must pass before next task
-
-### Task 6: Verify acceptance criteria and run full test suite
-- [x] verify all requirements from Overview are implemented
-- [x] verify edge cases are handled (network errors, invalid responses, rate limit blocking)
-- [x] run full test suite (unit tests)
-- [x] run linter - all issues must be fixed
-- [x] verify test coverage meets project standard (80%+)
-
-## Technical Details
-### Data Structures
-- MusicBrainzClient: wraps *http.Client with rate limiter and config
-- ExternalRelease: matches existing database struct with addition of CachedAt time.Time
-- MusicBrainz API Response Models: ReleaseGroup, Artist, etc. based on XML schema
-
-### Parameters and Formats
-- Rate Limiter: 1 request per second burst size of 1 (strict limit)
-- Cache TTL: configurable via MusicBrainzConfig.CacheTTL (default 24h)
-- API Endpoint: https://musicbrainz.org/ws/2/ with proper User-Agent header
-- Response Format: XML parsing of MusicBrainz Web Service responses
-
-### Processing Flow
-1. SyncArtistDiscography called with MusicBrainz Artist ID
-2. Check cache: query external_releases for RGIDs with cached_at within TTL
-3. If cache miss or expired: call MusicBrainz API with rate limiting
-4. Parse XML response into ReleaseGroup models
-5. Apply status/type filtering (Bootleg/Promotion/Pseudo-Release excluded)
-6. Apply per-artist type filtering ( Singles/Compilations toggle via Web UI)
-7. Normalize strings (remove special chars, years, brackets for fuzzy matching)
-8. Upsert each Release Group to external_releases with current timestamp
-9. Return list of Release Groups for scanner consumption
-
-## Post-Completion
-*Items requiring manual intervention or external systems - no checkboxes, informational only*
-
-**Manual verification** (if applicable):
-- Manual testing of rate limiting under load
-- Verify cache expiration behavior over time
-- Test with real MusicBrainz API to ensure compliance with their usage policy
-- Performance testing of XML parsing and filtering logic
-
-**External system updates** (if applicable):
-- None - this is a standalone provider implementation

docs/plans/completed/2026-07-19-notifier-webui-sync.md

@@ -1,190 +0,0 @@
-# Notifier, Web UI & Sync Wiring
-
-## Overview
-Transform NaviWatcher from a compute-only daemon (which only logs missing
-releases) into a working service:
-1. **Sync wiring** in `main.run()` — a periodic loop that pulls artists/albums
-   from Navidrome into the DB, resolves each artist's MusicBrainz ID, syncs
-   their discography, then runs the scanner. This is the missing data pipeline
-   that currently makes every other component a no-op against an empty DB.
-2. **Notifier** — Telegram bot + cron scheduler that sends a daily digest of
-   newly-found missing releases (using existing `notifications_sent` primitives).
-3. **Web UI** — `net/http` + `html/template` dashboard with artist detail view,
-   archive of ignored releases, ignore actions, and basic auth.
-
-Problem solved: today `main.run()` calls `scanner.ScanAll` over empty tables and
-blocks on `<-ctx.Done()`. Nothing populates `artist_settings` / `local_albums` /
-`external_releases`, so Notifier and Web UI have nothing to show. This plan
-closes that gap end-to-end.
-
-Out of scope (deferred): Docker packaging, secondary-type filtering
-(`Live`/`Remix`/`Soundtrack`), bootleg exclusion at the engine level, full
-type-filtering config toggles. Per-artist `ignore_singles`/`ignore_compilations`
-filtering already works inside `musicbrainz.SyncArtistDiscography`.
-
-## Context (from discovery)
-- `internal/navidrome/{client,sync}.go` — `SyncArtists`, `SyncAlbums` exist and
-  write `artist_settings` / `local_albums`. **Gap:** `ArtistInfo` only carries
-  Navidrome `ID`/`Name`; there is **no MusicBrainz ID (MBID)**, but
-  `musicbrainz.SyncArtistDiscography` requires `artistMBID`.
-- `internal/musicbrainz/{client,sync,api}.go` — `SyncArtistDiscography(ctx, client,
-  db, artistID, artistMBID, ttl)` works once MBID is known. `getArtistFilterOptions`
-  already reads `ignore_singles`/`ignore_compilations`.
-- `internal/database/` — `GetAllArtistSettings`, `GetExternalReleasesByArtist`,
-  `GetUnnotifiedReleases`, `MarkNotificationSent`, `GetIgnoredReleases`,
-  `SetReleaseIgnored` all exist and are tested. `artist_settings` schema has no
-  MBID column.
-- `internal/scanner/scan.go` — `ScanAll(ctx, db, threshold)` returns
-  `[]MissingRelease`; tested and working.
-- `cmd/naviwatcher/main.go` — `App` holds cfg/db/mbClient only; `run()` is the
-  compute-only stub. `NewApp` constructs the MusicBrainz client but **not** the
-  Navidrome client. No goroutines for sync/notifier/web.
-- `internal/config/config.go` — `TelegramConfig{Enabled,Token,ChatID,CronSchedule}`
-  and `ServerConfig{Host,Port,Username,Password}` already defined but unused.
-- `config.yaml.example` exists.
-
-### Key decision: how to obtain the MusicBrainz ID
-`SyncArtistDiscography` needs an MBID. Navidrome's Subsonic API does not return
-MBIDs via `getArtists`/`getArtist`. Resolution: **add an `mbid` column to
-`artist_settings`** and resolve it lazily during sync by querying MusicBrainz
-artist search (`/ws/2/artist/?query=artist:<name>&fmt=json`). Cache the MBID on
-the artist row. This avoids manual config and keeps the schema the single source
-of truth. (Alternative considered: resolve by name on every sync without
-storing — rejected because it doubles rate-limited MB calls and is flaky on
-name collisions.)
-
-## Development Approach
-- **Testing approach**: TDD — write tests before implementation for each task.
-- Complete each task fully (code + tests passing) before the next.
-- Every task MUST include new/updated tests (success + error/edge cases).
-- All tests must pass before starting the next task.
-- Run `go test ./...` and `go vet ./...` after each task.
-- Maintain backward compatibility of existing DB schema (additive migration only).
-
-## Testing Strategy
-- **Unit tests** for every new function/method (success + error paths).
-- **Integration-style tests** for sync/resolver using a `:memory:` DB and a
-  stubbed MusicBrainz HTTP client (the existing `client_test.go` already shows
-  the httptest pattern — reuse it).
-- **Web UI**: table-driven tests for handlers (status codes, auth rejection,
-  ignore action effects on DB) using `httptest.NewServer` + in-memory DB. No
-  Playwright/Cypress in this project, so no e2e suite; handler tests cover the
-  equivalent surface.
-- **Notifier**: test digest formatting and the sent-tracking logic against
-  `:memory:` DB with a stubbed Telegram sender (interface so the real HTTP bot
-  is injectable).
-
-## Progress Tracking
-- Mark completed items with `[x]` immediately when done.
-- Add newly discovered tasks with ➕ prefix.
-- Document issues/blockers with ⚠️ prefix.
-- Keep plan in sync with actual work.
-
-## Implementation Steps
-
-### Task 1: Add `mbid` column to artist_settings
-- [x] add migration `006_add_mbid_to_artist_settings` (`ALTER TABLE artist_settings ADD COLUMN mbid TEXT;`)
-- [x] extend `ArtistSettings` struct + `SaveArtistSettings`/`UpsertArtist` to persist `MBID`
-- [x] write tests for migration + struct round-trip (empty MBID allowed, set/get)
-- [x] run tests - must pass before task 2
-
-### Task 2: MusicBrainz artist-ID resolver
-- [x] add `ResolveArtistMBID(ctx, client, name) (string, error)` in `internal/musicbrainz` using `/ws/2/artist/?query=artist:<name>&fmt=json`
-- [x] parse first matching artist ID from JSON response; return error if none
-- [x] write tests with httptest stub (match found, no match, HTTP error)
-- [x] run tests - must pass before task 3
-
-### Task 3: Periodic sync pipeline
-- [x] add `SyncAll(ctx, ndClient, mbClient, db, ttl)` orchestrator: for each monitored artist → ensure MBID (resolve + persist if missing) → `musicbrainz.SyncArtistDiscography` → `navidrome.SyncAlbums`
-- [x] wire `navidrome.NewClient` into `App`; add `ndClient` field
-- [x] write tests for `SyncAll` with stubbed clients + `:memory:` DB (new artist gets MBID, existing MBID reused, unmonitored skipped)
-- [x] run tests - must pass before task 4
-
-### Task 4: Main loop wiring (sync → scan)
-- [x] replace compute-only `run()` with: one immediate sync+scan, then a ticker-driven periodic sync+scan goroutine; keep graceful shutdown via ctx
-- [x] add a `syncInterval` config field (default e.g. 6h) to `config.go` + defaults + validation
-- [x] write tests for the loop scheduling logic where feasible (ticker fires, ctx cancels cleanly)
-- [x] run tests - must pass before task 5
-
-### Task 5: Notifier — Telegram sender + digest
-- [x] define `Sender` interface (`Send(ctx, message string) error`) and a `telegramSender` using `TelegramConfig` (bot API `sendMessage`)
-- [x] add `FormatDigest(missing []scanner.MissingRelease, uiBaseURL string) string` (artist names + counts + Web UI link)
-- [x] write tests: digest formatting, sender failure handling (stub sender)
-- [x] run tests - must pass before task 6
-
-### Task 6: Notifier — scheduler + sent-tracking
-- [x] add `NotifyOnce(ctx, db, sender, cfg)` : query `GetUnnotifiedReleases`, build digest, send, `MarkNotificationSent` per rgid
-- [x] add cron-based scheduler goroutine honoring `TelegramConfig.CronSchedule` (use a lightweight cron lib or robfig/cron); no-op if `Enabled=false`
-- [x] write tests: `NotifyOnce` marks sent and skips already-sent; scheduler parses cron and fires (inject fixed time / use every-minute for test)
-- [x] run tests - must pass before task 7
-
-### Task 7: Web UI — server + auth + dashboard
-- [x] create `internal/web` with `Server` (net/http), `//go:embed` templates, basic-auth middleware using `ServerConfig.Username/Password`
-- [x] dashboard handler: list monitored artists with missing-release counts (join scanner result / external vs local)
-- [x] write tests: unauthenticated request → 401; authenticated → 200 with expected artist rendered
-- [x] run tests - must pass before task 8
-
-### Task 8: Web UI — artist detail + archive + ignore actions
-- [x] artist page: local albums (Subsonic) + found missing (MB cache) + ignore buttons
-- [x] archive page: `GetIgnoredReleases` with restore action
-- [x] POST handlers: `SetReleaseIgnored(rgid, true/false)`; "ignore all singles of artist" toggles `artist_settings.ignore_singles`
-- [x] write tests: ignore sets flag + removes from dashboard missing; restore clears flag; auth enforced on POST
-- [x] run tests - must pass before task 9
-
-### Task 9: Verify acceptance criteria
-- [x] run full suite `go test ./...` — all pass
-- [x] run `go vet ./...` and `go build -o naviwatcher` — clean
-- [x] verify scan→notify→web data flow with a seeded `:memory:`/file DB smoke check
-- [x] verify config.yaml.example documents new `sync_interval` field
-
-### Task 10: Update documentation
-- [x] add a short "How it works now" note to README/CLAUDE.md if present
-- [x] note the new `sync_interval` config key in `config.yaml.example`
-
-## Technical Details
-- New migration `006` is additive; existing rows get `mbid = NULL` and are
-  resolved lazily on first sync.
-- `SyncAll` ordering matters: Navidrome first (populates `artist_settings`),
-  then MBID resolution, then MusicBrainz discography, then albums.
-- Notifier `Sender` interface keeps the real Telegram HTTP call injectable for
-  tests; respects MusicBrainz-style rate limiting only on the MB client, not TG.
-- Web UI basic auth uses `crypto/subtle.ConstantTimeCompare` on
-  `base64(user:pass)` per RFC 7617; no session/cookie needed.
-- Cron: `robfig/cron/v3` is the conventional choice; if dependency minimalism is
-  preferred, a tiny "every N hours" ticker can replace cron — will confirm at
-  implementation if not specified.
-
-## Post-Completion
-*Informational — no checkboxes*
-- **Manual verification**: run binary against a real Navidrome + MusicBrainz,
-  confirm dashboard populates, Telegram digest arrives at `cron_schedule`,
-  ignore/restore actions persist.
-- **External**: ensure `config.yaml.example` matches deployed config; Telegram
-  bot token/chat_id must be supplied by operator.
-
-## Follow-up fixes (post code review)
-After the plan's Tasks 1-10 merged, a code review surfaced and fixed:
-- **Duplicate notifications**: `SyncArtistDiscography` previously deleted
-  `notifications_sent` for the whole artist on every cache-miss re-sync, which
-  wiped "already notified" tracking and re-sent digests. Now only notifications
-  for releases that disappear are pruned, and surviving releases keep their sent
-  markers. Re-sync is FK-safe (uses `INSERT OR REPLACE` + `rgid NOT IN (…)`).
-- **Empty-discography caching**: artists with zero MusicBrainz release groups
-  were never cached (a `0`-row result was treated as a cache miss), re-fetching
-  every cycle. Added `artist_settings.last_synced` (migration `009`) as the cache
-  freshness signal so empty discographies honor the TTL.
-- **`main.run` wiring**: the Web UI server and Telegram notifier scheduler are
-  now constructed in `NewApp` and started as goroutines in `run()` (previously
-  only the sync loop ran).
-- **Overlap guard**: `startPeriodicSync` now skips a tick while a previous sync
-  is still in flight (buffered `done` channel) so syncs never overlap.
-- **`server.public_url` config**: added so Telegram digest links use an
-  externally-reachable origin instead of the bind `host:port` (which defaults to
-  `0.0.0.0`). `NewServerWithConfig` falls back to host:port only for a real host.
-- **Web handlers**: artist detail page now uses `scanner.ScanArtist` (per-artist)
-  instead of a full `ScanAll`; removed the always-false `releaseIgnored` lookup
-  and dead `endsWith` helper; the configured fuzzy threshold is now threaded
-  through `Server`.
-- **DB connection pooling**: `:memory:` databases now use `SetMaxOpenConns(1)`
-  so migrations and queries share one in-memory store (prevents "missing column"
-  errors under the connection pool).

docs/plans/completed/2026-07-19-scanner-engine-fuzzy-diff.md

@@ -1,118 +0,0 @@
-# Scanner Engine: Fuzzy Diff (local vs external releases)
-
-## Overview
-- Implement the **Scanner Engine** — the missing core of NaviWatcher. It compares a user's local albums (from Navidrome, stored in `local_albums`) against an artist's external discography (from MusicBrainz, stored in `external_releases`) and returns the list of **missing releases** (external releases with no sufficiently similar local album).
-- Problem solved: without this, `main.run()` is empty and the service cannot fulfil its stated purpose (find missing albums and notify). This plan delivers only the computation core; persistence, notifier, and Web UI are explicitly out of scope.
-- Integrates with existing data layer: reads `database.LocalAlbum` and `database.ExternalRelease`, reuses normalization logic, and consumes `config.Scanner.FuzzyThreshold` (default 0.85).
-
-## Context (from discovery)
-- Files/components involved:
-  - `internal/database/local_albums.go` — `LocalAlbum{ID, ArtistID, Title}`, accessors `GetLocalAlbumsByArtist`, `GetAllLocalAlbums`, `GetLocalAlbums` (to confirm names during impl).
-  - `internal/database/external_releases.go` — `ExternalRelease{RGID, ArtistID, Title, Type, ReleaseDate, IsIgnored, CachedAt}`, accessors `GetExternalReleasesByArtist`, `GetIgnoredReleases`.
-  - `internal/database/database.go:176-191` — struct definitions.
-  - `internal/config/config.go:50-54` — `ScannerConfig{FuzzyThreshold, IgnoreBootlegs, IncludeCompilations}`.
-  - `internal/musicbrainz/api.go:132-165` — existing `NormalizeString` / `NormalizeArtistName` (regexes precompiled at init).
-  - `cmd/naviwatcher/main.go` — `App` struct, `NewApp`, empty `run()`.
-  - `go.mod` — **no fuzzy library present**; `lithammer/fuzzysearch` must be added.
-- Related patterns found:
-  - MusicBrainz provider uses `ctx.Err()` checks before/within loops, `fmt.Errorf("...: %w", err)` wrapping, `db.Begin()`/`defer tx.Rollback()`/`tx.Commit()`, and table-driven white-box tests with `newTestDB(t, ":memory:")` + `seedArtist` fixtures.
-  - Existing `NormalizeString` already covers: lowercase, strip `[...]`/`(...)`, strip years `(1|2)xxx`, strip non-alphanumerics, collapse spaces. Bracket stripping removes keywords like Deluxe/Anniversary/Expanded regardless of a keyword list.
-- Dependencies identified:
-  - New dep: `github.com/lithammer/fuzzysearch` (specified in Specification.md §2).
-  - New package: `internal/normalize` (extracted from `musicbrainz.NormalizeString`).
-  - New package: `internal/scanner` (the engine).
-
-## Development Approach
-- **Testing approach**: TDD — write/extend tests alongside every task's code.
-- Complete each task fully (code + tests passing) before moving to the next.
-- **CRITICAL: every task MUST include new/updated tests** for code changes in that task (success + error/edge cases).
-- **CRITICAL: all tests must pass before starting next task** — no exceptions.
-- Update this plan file when scope changes; mark items `[x]` immediately on completion.
-- Reuse existing test helpers (`newTestDB`, `seedArtist`, table-driven style) and the same error-wrapping/context conventions.
-
-## Testing Strategy
-- **Unit tests** (required per task): normalization, similarity scoring, and the scanner diff are all pure functions — ideal for table-driven tests with no DB. Scanner diff against DB uses `:memory:` SQLite + `seedArtist` fixtures, mirroring `musicbrainz/sync_test.go`.
-- No UI/e2e in this plan (Web UI is out of scope).
-
-## Progress Tracking
-- Mark completed items with `[x]` immediately when done.
-- Add newly discovered tasks with ➕ prefix.
-- Document blockers with ⚠️ prefix.
-- Keep plan in sync with actual work done.
-
-## What Goes Where
-- **Implementation Steps** (`[ ]`): all code + test tasks below.
-- **Post-Completion** (no checkboxes): manual/integration verification notes.
-
-## Implementation Steps
-
-### Task 1: Add fuzzysearch dependency
-- [x] run `go get github.com/lithammer/fuzzysearch@latest` and confirm it appears in `go.mod`/`go.sum`
-- [x] run `go mod tidy` and verify the build still compiles (`go build ./...`)
-- [x] write a trivial smoke test (or rely on Task 3's first test) confirming `fuzzy.Ratio` is importable and returns expected ordering
-- [x] run tests — must pass before task 2
-
-> Note: the library exposes `fuzzy.RankMatch` (subsequence-ranked Levenshtein distance: 0=exact, -1=no match) rather than a `fuzzy.Ratio` 0-100 function assumed in the plan. Task 3 will normalize this into a 0.0-1.0 similarity score.
-
-### Task 2: Extract normalization into `internal/normalize`
-- [x] create `internal/normalize/normalize.go` with `NormalizeString(s string) string` and `NormalizeArtistName(s string) string`, moving the regexes + logic from `internal/musicbrainz/api.go:132-165`
-- [x] refactor `internal/musicbrainz/api.go` to call `normalize.NormalizeString` / `normalize.NormalizeArtistName` instead of its local copies (remove duplicated regexes/functions)
-- [x] write tests `internal/normalize/normalize_test.go` (table-driven): lowercase, bracket/paren strip, year strip `(20xx)`, special-char strip, space collapse, `NormalizeArtistName` prefix strip (`the `/`a `/`an `)
-- [x] update existing `internal/musicbrainz/api_test.go` if it referenced the moved functions, ensuring it still passes
-- [x] run tests — must pass before task 3
-
-### Task 3: Implement similarity scoring in `internal/scanner`
-- [x] create `internal/scanner/scanner.go` with `Similarity(a, b string) float64` using `normalize.NormalizeString` + `fuzzy.LevenshteinDistance` (normalized to 0.0–1.0); define `IsMatch(a, b string, threshold float64) bool`
-- [x] write tests `internal/scanner/scanner_test.go` (table-driven): exact match → 1.0, `(Remastered)` / year variants still match above 0.85, clearly different titles → below threshold, empty-string handling
-- [x] run tests — must pass before task 4
-
-### Task 4: Implement the diff engine (missing-release detection)
-- [x] add `type MissingRelease struct { RGID, ArtistID, Title, Type, ReleaseDate string }` in `internal/scanner`
-- [x] implement `FindMissingReleases(local []database.LocalAlbum, external []database.ExternalRelease, threshold float64) []MissingRelease`:
-  - skip external releases where `IsIgnored == true`
-  - for each external release, check if any local album (same ArtistID) is a match via `IsMatch`; if none matches, it is missing
-  - respect context cancellation if signature uses `ctx` (decide in impl; pure slice version preferred for testability)
-- [x] write tests `internal/scanner/scanner_test.go` (table-driven, using in-memory DB fixtures or hand-built slices): no local albums → all external are missing; exact title present → not missing; fuzzy title present (e.g. `The Wall` vs `The Wall (Remastered)`) → not missing; ignored external → never reported; different ArtistID → not matched across artists; threshold boundary (0.85) behaviour
-- [x] run tests — must pass before task 5
-
-### Task 5: Wire a DB-backed scanner entrypoint + `main.go` hook (compute-only)
-- [x] add `func ScanArtist(ctx context.Context, db *database.DB, artistID string, threshold float64) ([]MissingRelease, error)` that loads local + external by artist via `database.GetLocalAlbumsByArtist` / `database.GetExternalReleasesByArtist` and calls `FindMissingReleases`
-- [x] add `func ScanAll(ctx context.Context, db *database.DB, threshold float64) ([]MissingRelease, error)` iterating monitored artists (reuse `database.GetAllArtistSettings`) with `ctx.Err()` checks between artists
-- [x] write tests `internal/scanner/scan_test.go` using `newTestDB(t)` + `seedArtist` + seeded `local_albums`/`external_releases` rows; assert missing set matches expectations; test ctx-cancellation returns early
-- [x] extend `cmd/naviwatcher/main.go` `App` struct + `NewApp` to construct the scanner (or keep stateless) and add a compute-only call in `run()` (e.g. log count of missing releases for monitored artists) without starting notifier/web — keep `run()` non-blocking / goroutine-safe per spec concurrency note
-- [x] write/extend `cmd/naviwatcher/main_test.go` if `App`/wiring changed
-- [x] run full test suite (`go test ./...`) and `go vet ./...` — must pass before final task
-
-### Task 6: Verify acceptance criteria
-- [x] verify `FindMissingReleases`/`ScanArtist`/`ScanAll` meet spec: normalization + 0.85 fuzzy threshold, ignore `IsIgnored`, per-artist scoping (confirmed via tests in scanner_test.go / scan_test.go; grep of diff.go + scan.go shows normalizing via normalize.NormalizeString, IsIgnored skip, ArtistID grouping)
-- [x] verify `config.Scanner.FuzzyThreshold` default 0.85 is used when threshold arg is zero (resolveThreshold in scanner.go returns DefaultThreshold=0.85 on zero; TestScanArtist_ZeroThresholdUsesDefault asserts zero==explicit default)
-- [x] run full test suite (unit) — all green (`go test ./...` passes)
-- [x] run `go vet ./...` and `gofmt -l ./internal ./cmd` — zero issues (fixed two unformatted test files)
-- [x] verify test coverage of `internal/scanner` and `internal/normalize` (target 80%+) — scanner 90.3%, normalize 100.0%
-
-### Task 7: Update documentation
-- [x] update `README.md` to note the Scanner Engine is implemented (compute-only; notifier/web pending)
-- [x] add a short note in `CLAUDE.md` or a plan-completion comment if new package conventions (e.g. `internal/normalize` is the shared normalization home) were established
-
-## Technical Details
-- **Normalization** (`internal/normalize`): port regexes from `musicbrainz/api.go`:
-  - `bracketRe` = `\[[^\]]*\]` , `parenRe` = `\([^)]*\)`, `yearRe` = `\b(1[0-9]{3}|2[0-9]{3})\b`, `spaceRe` = `\s+`.
-  - `NormalizeString`: lowercase → strip brackets/parens → strip years → replace `-`/`_` with space → keep `[a-z0-9 ]` → collapse spaces → trim.
-  - `NormalizeArtistName`: `NormalizeString` then strip leading `the `/`a `/`an ` tokens.
-- **Similarity**: `fuzzy.LevenshteinDistance(normalize(a), normalize(b))` returns an int edit distance; `Similarity` returns `1.0 - float64(dist)/float64(maxLen)` (clamped to [0.0, 1.0]). Empty/whitespace-only inputs normalize to empty and score 0.0 (no false match). `IsMatch` returns `Similarity(a,b) >= threshold`. Note: `fuzzy.Ratio` does not exist in `lithammer/fuzzysearch` v1.1.8 — `LevenshteinDistance` is used instead (contrary to earlier plan assumption).
-- **Diff algorithm**: per external release (filtered by `!IsIgnored`), compare normalized title against each local album of the same `ArtistID`; missing if no `IsMatch` at `threshold`.
-- **Config contract**: `threshold` passed from `config.Scanner.FuzzyThreshold` (default 0.85). Decide: if caller passes `0`, use default — implement explicitly and document.
-- **No new DB tables** in this plan (compute-only per user decision).
-
-## Post-Completion
-*Informational only — no checkboxes.*
-
-**Manual verification** (optional, requires live Navidrome + MusicBrainz cache):
-- Run the binary with a real `config.yaml`, observe `run()` log line reporting missing-release counts for monitored artists.
-- Confirm no false positives for `(Remastered)` / year-suffixed local titles.
-
-**Follow-up (out of scope, future plans)**:
-- Persist `MissingRelease` into a new `missing_releases` table for notifier/Web UI.
-- Implement Notifier (Telegram bot + cron) consuming scanner output.
-- Implement Web UI (dashboard / artist / archive) with basic-auth and `//go:embed` templates.
-- Replace the compute-only `run()` hook with full goroutine orchestration (scanner + notifier + web).

docs/plans/completed/2026-07-21-fix-review-findings.md

@@ -1,106 +0,0 @@
-# Fix Code Review Findings
-
-## Overview
-Fix the MAJOR and MINOR issues identified in the max-effort code review of the Notifier+WebUI+Sync branch. The most critical issues are filter inconsistencies across cache-hit, cache-miss, and read-time paths that cause releases to incorrectly appear/disappear from the dashboard depending on MusicBrainz cache state.
-
-Problem: Three separate filter implementations (`musicbrainz.FilterReleaseGroups`, `musicbrainz.SyncArtistDiscography` cache-hit path, `scanner.TypeFilter.suppressed`) have divergent logic for `IgnoreSingles`/`IgnoreCompilations` toggles — specifically, whether `EP` secondary type counts as a Single.
-
-## Context (from review)
-- **Files involved:**
-  - `internal/musicbrainz/api.go` — `FilterReleaseGroups`, `hasSliceType` (variadic)
-  - `internal/musicbrainz/sync.go` — `SyncArtistDiscography` cache-hit filter (line 93-115)
-  - `internal/scanner/diff.go` — `TypeFilter.suppressed`, `hasType` (exact match)
-  - `internal/database/external_releases.go` — `ArtistCacheFresh` lexicographic time comparison
-  - `internal/musicbrainz/sync.go` — stale notification pruning (parameter limit)
-  - `internal/scanner/scan.go` — `ScanArtist` missing `ErrArtistNotFound` handling
-  - `internal/notifier/scheduler.go` — `NotifyOnce` RGID-only map key
-  - `internal/database/artist_settings.go` — `SaveArtistSettings` subquery inefficiency
-
-- **Key pattern:** Centralized filter logic should exist in one place; all three paths should delegate to it.
-- **Dependencies:** `hasSliceType` in `api.go` is the canonical implementation (handles `Single` + `EP` for `IgnoreSingles`).
-
-## Development Approach
-- **Testing approach**: TDD — write tests before implementation for each fix
-- Complete each task fully (code + tests passing) before the next
-- **CRITICAL: every task MUST include new/updated tests** for code changes
-- All tests must pass before starting next task (`go test ./...`)
-- Update this plan if scope changes during implementation
-
-## Testing Strategy
-- **Unit tests** for every modified function (success + error cases)
-- **Integration-style tests** for filter behavior across cache boundaries (using in-memory DB + stubbed MB client)
-- No e2e framework in project; handler tests cover equivalent surface
-
-## Progress Tracking
-- Mark completed items with `[x]` immediately when done
-- Add newly discovered tasks with `➕` prefix
-- Document issues/blockers with `⚠️` prefix
-
-## Implementation Steps
-
-### Task 1: Centralize filter logic into shared helper
-- [x] Create `internal/musicbrainz/filter.go` with `ApplyTypeToggles(releases []ExternalRelease, opts FilterOptions) []ExternalRelease` that implements the canonical logic: `IgnoreSingles` → filter where `Type=="Single" OR hasSliceType(SecondaryTypes, "Single", "EP")`; `IgnoreCompilations` → filter where `Type=="Compilation" OR hasSliceType(SecondaryTypes, "Compilation")`
-- [x] Move `hasSliceType` and `FilterOptions` struct to the new file (or keep in api.go and import)
-- [x] Write tests for `ApplyTypeToggles`: table-driven covering Single, EP, Compilation, Album with various SecondaryTypes combinations
-- [x] Run tests - must pass before task 2
-
-### Task 2: Update musicbrainz.FilterReleaseGroups to use centralized helper
-- [x] Refactor `FilterReleaseGroups` in `api.go` to call `ApplyTypeToggles` (or inline the shared logic if keeping in same package)
-- [x] Ensure existing `api_test.go` tests still pass (filter behavior unchanged for cache-miss path)
-- [x] Run tests - must pass before task 3
-
-### Task 3: Fix sync.go cache-hit path to use centralized filter
-- [x] Update `SyncArtistDiscography` cache-hit branch to call the shared filter helper instead of inline logic
-- [x] Ensure `opts` from `getArtistFilterOptions` is passed correctly
-- [x] Write test in `sync_test.go` that verifies cache-hit path produces identical filter results as cache-miss path for same `FilterOptions` and release data
-- [x] Run tests - must pass before task 4
-
-### Task 4: Fix scanner diff.go TypeFilter.suppressed to use centralized filter
-- [x] Update `TypeFilter.suppressed` in `diff.go` to use the same logic as `ApplyTypeToggles` (i.e., treat `EP` in SecondaryTypes as a Single when `IgnoreSingles=true`)
-- [x] Since scanner is separate package, either: (a) export `ApplyTypeToggles` from musicbrainz and import, or (b) duplicate the minimal logic with a comment referencing the canonical source. Choose (a) for DRY.
-- [x] Update `scanner/diff.go` to import `musicbrainz` and use the shared filter
-- [x] Write tests in `diff_test.go` verifying scanner filter matches musicbrainz filter for all release type combinations
-- [x] Run tests - must pass before task 5
-
-### Task 5: Fix ArtistCacheFresh lexicographic time comparison
-- [x] Change `external_releases.cached_at` from TEXT to INTEGER (unix epoch seconds) via migration `010_cached_at_to_integer`
-- [x] Update `FormatCachedAt` to return `time.Time.Unix()` (int64)
-- [x] Update `ArtistCacheFresh` query to compare `cached_at >= ?` as integers
-- [x] Update `SaveExternalRelease` and sync insert to store integer timestamp
-- [x] Write tests: verify cache freshness check works across format change; test migration on existing DB
-- [x] Run tests - must pass before task 6
-
-### Task 6: Batch stale notification pruning to avoid SQLite parameter limit
-- [x] Modify stale notification deletion in `sync.go` (lines 150-185) to process in chunks of 500 parameters
-- [x] Write test with >1000 synthetic release groups to verify no parameter-limit error
-- [x] Run tests - must pass before task 7
-
-### Task 7: Handle ErrArtistNotFound in ScanArtist gracefully
-- [x] In `ScanArtist`, wrap `GetArtistSettings` call; if `ErrArtistNotFound`, use empty `TypeFilter` (no filtering) instead of returning error
-- [x] Write test: create external_releases row for non-existent artist_id, verify ScanArtist succeeds and returns missing releases (with default no-filter behavior)
-- [x] Run tests - must pass before task 8
-
-### Task 8: Fix NotifyOnce map key to use composite ArtistID+RGID
-- [x] Change `missingByRGID` map key from `m.RGID` to `m.ArtistID + "|" + m.RGID` (or use a struct key)
-- [x] Update lookup from `unnotified` slice similarly
-- [x] Add comment documenting that RGID is globally unique in MusicBrainz (UUID) so single-key is theoretically safe, but composite is defensive
-- [x] Write test verifying composite key works and doesn't break existing behavior
-- [x] Run tests - must pass before task 9
-
-### Task 9: Remove SaveArtistSettings INSERT subquery inefficiency (minor)
-- [x] Rewrite `SaveArtistSettings` to use two statements: INSERT with explicit values, then UPDATE on conflict (or use UPSERT with COALESCE for all columns including last_synced)
-- [x] Ensure `last_synced` is preserved on update via `COALESCE(excluded.last_synced, artist_settings.last_synced)`
-- [x] Write test verifying `last_synced` preserved on update
-- [x] Run tests - must pass before task 10
-
-### Task 10: Verify acceptance criteria and full test suite
-- [x] Run `go test ./...` — all pass
-- [x] Run `go vet ./...` — clean
-- [x] Run `go build -o naviwatcher` — clean
-- [x] Verify filter consistency: write an integration test that seeds DB with releases having SecondaryTypes=["EP"], toggles IgnoreSingles, and confirms the release is filtered regardless of cache state (cache-hit vs cache-miss vs scanner)
-- [x] Update `config.yaml.example` if any new config fields added
-- [x] Run tests - must pass
-
-### Task 11: Update documentation
-- [x] Update README.md if any new behavior or config documented
-- [x] Note the filter centralization pattern in CLAUDE.md if new pattern established

docs/plans/completed/2026-07-26-fix-scanner-wiring.md

@@ -1,103 +0,0 @@
-# Fix scanner engine wiring gap
-
-## Overview
-Fix the scanner engine wiring gap where the data producers (MusicBrainz/Navidrome sync) are implemented but never invoked by main.run(). Currently, main.run() only calls scanner.ScanAll and logs results, without calling musicbrainz.SyncArtistDiscography or any Navidrome sync, so the external_releases and local_albums tables are never populated by the running process.
-
-This plan implements Approach A: Sequential sync then scan - modifying App.run() to call navidrome.SyncArtists, musicbrainz.SyncAll, then scanner.ScanAll in sequence.
-
-## Context (from discovery)
-- Files/components involved: cmd/naviwatcher/main.go, internal/musicbrainz/sync.go, internal/musicbrainz/syncall.go, internal/navidrome/sync.go, internal/scanner/scan.go
-- Related patterns found: Existing sync functions are implemented but not wired in main execution flow
-- Dependencies identified: MusicBrainz client, Navidrome client, database connections all already initialized in App
-
-## Development Approach
-- **Testing approach**: TDD (Tests first) - Write tests for the modified flow before implementing changes
-- Complete each task fully before moving to the next
-- Make small, focused changes
-- **CRITICAL: every task MUST include new/updated tests** for code changes in that task
-- Tests are not optional - they are a required part of the checklist
-- Write unit tests for new functions/methods
-- Write unit tests for modified functions/methods
-- Add new test cases for new code paths
-- Update existing test cases if behavior changes
-- Tests cover both success and error scenarios
-- **CRITICAL: all tests must pass before starting next task** - no exceptions
-- **CRITICAL: update this plan file when scope changes during implementation**
-- Run tests after each change
-- Maintain backward compatibility
-
-## Testing Strategy
-- **Unit tests**: Required for every task (see Development Approach above)
-- **E2E tests**: Project has existing test structure - maintain and extend as needed
-  - UI changes → add/update e2e tests in same task as UI code
-  - Backend changes supporting UI → add/update e2e tests in same task
-  - Treat e2e tests with same rigor as unit tests (must pass before next task)
-  - Store e2e tests alongside unit tests (or in designated e2e directory)
-
-## Progress Tracking
-- Mark completed items with `[x]` immediately when done
-- Add newly discovered tasks with ➕ prefix
-- Document issues/blockers with ⚠️ prefix
-- Update plan if implementation deviates from original scope
-- Keep plan in sync with actual work done
-
-## What Goes Where
-- **Implementation Steps** (`[ ]` checkboxes): tasks achievable within this codebase - code changes, tests, documentation updates
-- **Post-Completion** (no checkboxes): items requiring external action - manual testing, changes in consuming projects, deployment configs, third-party verifications
-- **Checkbox placement**: Belong ONLY in Task sections (`### Task N:` or `### Iteration N:`). Do NOT put checkboxes in Success criteria, Overview, or Context — they cause extra loop iterations.
-
-## Implementation Steps
-
-### Task 1: Understand current main.run() flow and identify integration points
-- [x] Review current main.run() function in cmd/naviwatcher/main.go
-- [x] Identify where navidrome.SyncArtists, musicbrainz.SyncAll, and scanner.ScanAll should be called
-- [x] Examine existing App.syncAndScan() function to understand current scanning logic
-- [x] Write tests to verify current behavior (scanner runs without data sync)
-- [x] Run tests - must pass before proceeding
-
-### Task 2: Modify App.run() to include data synchronization before scanning
-- [x] Modify App.run() to call navidrome.SyncArtists(ctx, a.ndClient, a.db) first
-- [x] Modify App.run() to call musicbrainz.SyncAll() with appropriate parameters
-- [x] Modify App.run() to call scanner.ScanAll() after data synchronization
-- [x] Ensure proper error handling and context propagation for each step
-- [x] Write tests verifying the new synchronization sequence works correctly
-- [x] Run tests - must pass before proceeding
-
-### Task 3: Update App.syncAndScan() to use the new synchronized approach (optional refactor)
-- [x] Evaluate whether App.syncAndScan() should be updated to use the new flow
-- [x] If modifying, ensure it calls the same sync functions in the same order
-- [x] Write tests to verify syncAndScan still works correctly
-- [x] Run tests - must pass before proceeding
-
-### Task 4: Verify end-to-end functionality works correctly
-- [x] Create integration test that verifies data flows from sync -> scan -> notification
-- [x] Test that artist settings (ignore_singles/ignore_compilations) are properly respected
-- [x] Verify that external_releases and local_albums tables get populated
-- [x] Run full test suite - must pass before proceeding
-
-### Task 5: Update documentation to reflect the new data flow
-- [x] Update CLAUDE.md if needed to document the new execution flow
-- [x] Update any relevant comments in the code
-- [x] Ensure documentation matches implementation
-- [x] Run final validation
-
-## Technical Details
-- Data structures: Uses existing database.ExternalRelease, database.LocalAlbum types
-- Parameters: Uses existing context.Context, database.DB, client instances
-- Processing flow: 
-  1. Sync artists from Navidrome (populate artist_settings)
-  2. Sync discographies from MusicBrainz (populate external_releases with filtering)
-  3. Sync albums from Navidrome (populate local_albums)
-  4. Scan for missing releases using fuzzy matching (produces MissingRelease results)
-
-## Post-Completion
-*Items requiring manual intervention or external systems - no checkboxes, informational only*
-
-**Manual verification** (if applicable):
-- Manual testing of the complete data pipeline with actual Navidrome and MusicBrainz services
-- Performance testing under load to ensure synchronization doesn't block excessively
-- Verification that configuration options still work as expected
-
-**External system updates** (if applicable):
-- Configuration documentation updates if new flags are added
-- Deployment procedure updates if startup time characteristics change significantly

docs/plans/completed/2026-07-27-verify-scanner-wiring.md

@@ -1,105 +0,0 @@
-# Verify and Document Scanner Wiring Implementation
-
-## Overview
-Verify that the scanner engine properly wires the ignore_singles and ignore_compilations toggles from artist_settings through both the MusicBrainz sync path and the scanner path. Ensure proper test coverage and document the data flow for clarity.
-
-## Context (from discovery)
-- Files/components involved: 
-  - cmd/naviwatcher/main.go (syncAndScan function)
-  - internal/scanner/scan.go (ScanArtist, ScanAll functions)
-  - internal/musicbrainz/sync.go (SyncArtistDiscography function)
-  - internal/musicbrainz/filter.go (ApplyTypeToggles functions)
-  - internal/database/artist_settings.go (GetArtistSettings, GetAllArtistSettings functions)
-- Related patterns found: Filter centralization pattern mentioned in CLAUDE.md
-- Dependencies identified: database package for artist settings access
-
-## Development Approach
-- **Testing approach**: TDD (tests first)
-- Complete each task fully before moving to the next
-- Make small, focused changes
-- **CRITICAL: every task MUST include new/updated tests** for code changes in that task
-  - tests are not optional - they are a required part of the checklist
-  - write unit tests for new functions/methods
-  - write unit tests for modified functions/methods
-  - add new test cases for new code paths
-  - update existing test cases if behavior changes
-  - tests cover both success and error scenarios
-- **CRITICAL: all tests must pass before starting next task** - no exceptions
-- **CRITICAL: update this plan file when scope changes during implementation**
-- Run tests after each change
-- Maintain backward compatibility
-
-## Solution Overview
-The implementation flow is:
-1. navidrome.SyncArtists populates artist_settings table
-2. musicbrainz.SyncAll calls SyncArtistDiscography which:
-   - Retrieves artist settings via getArtistFilterOptions
-   - Applies ignore_singles/ignore_compilations filters via ApplyTypeToggles
-   - Stores filtered results in external_releases table
-3. scanner.ScanAll iterates artists and calls ScanArtist which:
-   - Retrieves current artist settings via GetArtistSettings
-   - Applies ignore_singles/ignore_compilations filters via TypeFilter
-   - Compares local albums vs filtered external releases
-
-This creates two filtering points:
-- Storage-level filtering during MusicBrainz sync (optimizes storage)
-- Runtime filtering during scanning (ensures real-time responsiveness to setting changes)
-
-## Technical Details
-- Data flow: Navidrome artist sync → MusicBrainz discography sync (with filtering) → Navidrome album sync → Scanner (with filtering)
-- Key functions: 
-  - GetArtistSettings/GetAllArtistSettings (database layer)
-  - getArtistFilterOptions/ApplyTypeToggles (musicbrainz filtering)
-  - ScanArtist/ScanAll with TypeFilter (scanner filtering)
-- Data structures: ArtistSettings, TypeFilter, ExternalRelease, LocalAlbum, MissingRelease
-
-## What Goes Where
-- **Implementation Steps** (`[ ]` checkboxes): tasks achievable within this codebase - code changes, tests, documentation updates
-- **Post-Completion** (no checkboxes): items requiring external action - manual testing, changes in consuming projects, deployment configs, third-party verifications
-
-## Implementation Steps
-
-### Task 1: Verify Current Implementation
-- [x] Review cmd/naviwatcher/main.go syncAndScan function to confirm full pipeline execution
-- [x] Review internal/scanner/scan.go ScanArtist function for proper settings retrieval and filtering
-- [x] Review internal/scanner/scan.go ScanAll function for proper iteration and filtering application
-- [x] Review internal/musicbrainz/sync.go SyncArtistDiscography for proper settings retrieval and filtering
-- [x] Review internal/musicbrainz/filter.go ApplyTypeToggles functions for correct filtering logic
-- [x] Review internal/database/artist_settings.go for proper settings retrieval functions
-- [x] Write unit tests to verify the filtering logic works correctly in both paths
-- [x] Run existing test suite to ensure no regressions
-- [x] Must pass before next task
-
-### Task 2: Enhance Test Coverage
-- [x] Create comprehensive test cases for scanner filtering with various ignore_singles/ignore_compilations combinations
-- [x] Create comprehensive test cases for scanner filtering with various ignore_singles/ignore_compilations combinations
-- [x] Create test cases for MusicBrainz sync filtering with various scenarios
-- [x] Add integration tests that verify the full flow from settings change to filtered scan results
-- [x] Test edge cases: empty settings, null values, default behavior
-- [x] Write tests for error conditions and fallback behaviors
-- [x] Run tests to ensure they pass
-- [x] Must pass before next task
-
-### Task 3: Document the Data Flow
-- [x] Update documentation to clearly explain how ignore_singles/ignore_compilations settings propagate through the system
-- [x] Add comments to key functions explaining the filtering flow
-- [x] Ensure CLAUDE.md accurately reflects the current implementation
-- [x] Create diagrams or flowcharts if helpful for understanding
-- [x] Must pass before next task
-
-### Task 4: Final Verification
-- [x] Run full test suite to ensure all changes work correctly
-- [x] Verify no breaking changes were introduced
-- [x] Confirm that the implementation handles the use case described in the memory file
-- [x] Update this plan with completion status
-
-## Post-Completion
-*Items requiring manual intervention or external systems - no checkboxes, informational only*
-
-**Manual verification**:
-- Manual testing of the end-to-end flow with toggles enabled/disabled
-- Verification that changes to ignore_singles/ignore_compilations take effect in a timely manner
-- Performance testing to ensure filtering doesn't introduce significant overhead
-
-**External system updates**:
-- None required for this verification task

docs/plans/completed/2026-07-30-live-remix-filtering.md

@@ -1,80 +0,0 @@
-# Implement Live/Remix Filtering
-
-## Overview
-- Implement support for "Live" and "Remix" secondary type filtering for artist discographies.
-- Problem it solves: Users currently cannot filter out Live or Remix albums/singles, which can clutter the dashboard.
-- Key benefits: Improved user experience and cleaner discography views.
-
-## Context (from discovery)
-- Files/components involved: 
-  - `internal/database/database.go` (ArtistSettings struct)
-  - `internal/musicbrainz/filter.go` (FilterOptions, ApplyTypeToggles)
-  - `internal/web/handlers.go` (Artist detail view)
-  - `internal/web/templates/artist.html`
-- Related patterns found: Follows the existing pattern for `ignore_singles` and `ignore_compilations`.
-- Dependencies identified: `database` package, `musicbrainz` package, `web` package.
-
-## Development Approach
-- **Testing approach**: TDD (tests first)
-- Complete each task fully before moving to the next
-- Make small, focused changes
-- **CRITICAL: every task MUST include new/updated tests** for code changes in that task
-- **CRITICAL: all tests must pass before starting next task** - no exceptions
-- **CRITICAL: update this plan file when scope changes during implementation**
-- Run tests after each change
-- Maintain backward compatibility
-
-## Testing Strategy
-- **Unit tests**: required for every task (see Development Approach above)
-- **E2E tests**: None required for this scope.
-
-## Progress Tracking
-- Mark completed items with `[x]` immediately when done
-- Add newly discovered tasks with ➕ prefix
-- Document issues/blockers with ⚠️ prefix
-- Update plan if implementation deviates from original scope
-- Keep plan in sync with actual work done
-
-## What Goes Where
-- **Implementation Steps** (`[ ]` checkboxes): code changes, tests, documentation updates
-- **Post-Completion** (no checkboxes): manual testing of the scanner and web UI
-
-## Implementation Steps
-
-### Task 1: Update Database Schema and Model
-- [x] Update `ArtistSettings` struct in `internal/database/database.go` to include `IgnoreLive` and `IgnoreRemix` fields
-- [x] Create a migration or manual SQL script to add `ignore_live` and `ignore_remix` columns to `artist_settings` table
-- [x] Update `SaveArtistSettings` and `UpdateArtistSettings` to handle the new fields
-- [x] write unit tests for `ArtistSettings` struct and database operations
-- [x] run project tests - must pass before next task
-
-### Task 2: Update Filtering Core Logic
-- [x] Update `FilterOptions` struct in `internal/musicbrainz/filter.go` to include `IgnoreLive` and `IgnoreRemix`
-- [x] Update `ApplyTypeToggles` in `internal/musicbrainz/filter.go` to include logic for "Live" and "Remix" types
-- [x] write unit tests for `ApplyTypeToggles` covering all four toggle types (Single, Compilation, Live, Remix)
-- [x] run project tests - must pass before next task
-
-### Task 3: Update Web UI and Handlers
-- [x] Update `ArtistData` or similar view models to include the new filter booleans
-- [x] Update `internal/web/handlers.go` to handle the new toggle POST requests
-- [x] Update `internal/web/templates/artist.html` to show new toggles for Live and Remix
-- [x] write tests for new web handlers
-- [x] run project tests - must pass before next task
-
-### Task 4: Verify and Document
-- [x] Verify the scanner correctly suppresses "Live" and "Remix" types when toggles are enabled (manual test - verified via unit tests and implementation review)
-- [x] Verify the Web UI correctly updates the database on toggle change (manual test - verified via implementation review)
-- [x] Update `CLAUDE.md` or other docs if new patterns were discovered (no new patterns discovered - follows existing pattern)
-- [x] run full test suite
-- [x] verify no breaking changes were introduced
-
-## Technical Details
-- **Database**: `ignore_live` (boolean, default false), `ignore_remix` (boolean, default false)
-- **Filtering**: "Live" and "Remix" will be checked in both primary `Type` and `SecondaryTypes` slices.
-- **Web**: New endpoints will mirror existing `/ignore-singles` logic.
-
-## Post-Completion
-**Manual verification**:
-- Verify that toggling "Live" in the Web UI actually removes "Live" results from the scanner output.
-- Verify that toggling "Remix" in the Web UI actually removes "Remix" results from the scanner output.
-- Verify that these filters do not affect "Single" or "Compilation" filtering.

go.mod

@@ -3,15 +3,6 @@ module naviwatcher
 go 1.25.1
 
 require (
-	github.com/delucks/go-subsonic v0.0.0-20240806025900-2a743ec36238
 	github.com/mattn/go-sqlite3 v1.14.22
 	gopkg.in/yaml.v3 v3.0.1
 )
-
-require (
-	github.com/lithammer/fuzzysearch v1.1.8
-	github.com/robfig/cron/v3 v3.0.1
-	golang.org/x/time v0.15.0
-)
-
-require golang.org/x/text v0.9.0 // indirect

go.sum

@@ -1,45 +1,5 @@
-github.com/delucks/go-subsonic v0.0.0-20240806025900-2a743ec36238 h1:uejyepOdHISrJTw7P84Y7yEC0FMyv1q3KNDRxWsviKw=
-github.com/delucks/go-subsonic v0.0.0-20240806025900-2a743ec36238/go.mod h1:vnbEuj6Z20PLcHB4rrLQAOXGMjtULfMGhRVSFPcSdUo=
-github.com/lithammer/fuzzysearch v1.1.8 h1:/HIuJnjHuXS8bKaiTMeeDlW2/AyIWk2brx1V8LFgLN4=
-github.com/lithammer/fuzzysearch v1.1.8/go.mod h1:IdqeyBClc3FFqSzYq/MXESsS4S0FsZ5ajtkr5xPLts4=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
-github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
-golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

internal/config/config.go

@@ -15,7 +15,6 @@ type Config struct {
 	MusicBrainz MusicBrainzConfig `yaml:"musicbrainz"`
 	Telegram    TelegramConfig    `yaml:"telegram"`
 	Scanner     ScannerConfig     `yaml:"scanner"`
-	Sync        SyncConfig        `yaml:"sync"`
 }
 
 // ServerConfig holds HTTP server settings.
@@ -24,7 +23,6 @@ type ServerConfig struct {
 	Port     int    `yaml:"port"`
 	Username string `yaml:"username"`
 	Password string `yaml:"password"`
-	PublicURL string `yaml:"public_url"`
 }
 
 // NavidromeConfig holds Subsonic API connection details.
@@ -48,26 +46,11 @@ type TelegramConfig struct {
 	CronSchedule string `yaml:"cron_schedule"`
 }
 
-// SyncConfig holds periodic sync pipeline settings.
-type SyncConfig struct {
-	Interval time.Duration `yaml:"interval"`
-}
-
-// DefaultSyncInterval is the default period between full sync+scan runs when
-// sync.interval is not specified in the config file.
-const DefaultSyncInterval = 6 * time.Hour
-
 // ScannerConfig holds scanner engine parameters.
-//
-// Type filtering is handled in musicbrainz/api.go, not here: only Album/Single/EP
-// primary types (and release groups whose secondary types include Single/EP/Compilation)
-// are included. Bootlegs are not explicitly excluded — a release group whose primary
-// type is an included type but whose secondary types include "Bootleg" will still pass
-// through and may be reported as missing. Compilations are included by default but can
-// be excluded per-artist via artist_settings.ignore_compilations. These behaviours are
-// not user-toggleable at the global config level, so there are no corresponding config fields.
 type ScannerConfig struct {
 	FuzzyThreshold      float64 `yaml:"fuzzy_threshold"`
+	IgnoreBootlegs      bool    `yaml:"ignore_bootlegs"`
+	IncludeCompilations bool    `yaml:"include_compilations"`
 }
 
 // LoadConfig reads a YAML file from path, parses it, applies defaults,
@@ -103,12 +86,6 @@ func applyDefaults(cfg *Config) {
 	if cfg.Scanner.FuzzyThreshold == 0 {
 		cfg.Scanner.FuzzyThreshold = 0.85
 	}
-	if cfg.MusicBrainz.CacheTTL == 0 {
-		cfg.MusicBrainz.CacheTTL = 24 * time.Hour
-	}
-	if cfg.Sync.Interval == 0 {
-		cfg.Sync.Interval = DefaultSyncInterval
-	}
 }
 
 // validate checks that required fields are set and values are within acceptable ranges.
@@ -131,19 +108,5 @@ func validate(cfg *Config) error {
 	if cfg.MusicBrainz.UserAgent == "" {
 		return fmt.Errorf("musicbrainz.user_agent is required")
 	}
-	if cfg.Sync.Interval <= 0 {
-		return fmt.Errorf("sync.interval must be positive, got %v", cfg.Sync.Interval)
-	}
-	if cfg.Telegram.Enabled {
-		if cfg.Telegram.Token == "" {
-			return fmt.Errorf("telegram.token is required when telegram.enabled is true")
-		}
-		if cfg.Telegram.ChatID == "" {
-			return fmt.Errorf("telegram.chat_id is required when telegram.enabled is true")
-		}
-		if cfg.Telegram.CronSchedule == "" {
-			return fmt.Errorf("telegram.cron_schedule is required when telegram.enabled is true")
-		}
-	}
 	return nil
 }

internal/config/config_test.go

@@ -5,7 +5,6 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
-	"time"
 )
 
 func TestLoadConfig_Valid(t *testing.T) {
@@ -36,6 +35,8 @@ telegram:
 
 scanner:
   fuzzy_threshold: 0.9
+  ignore_bootlegs: true
+  include_compilations: false
 `
 	if err := os.WriteFile(path, []byte(yaml), 0644); err != nil {
 		t.Fatalf("failed to write config: %v", err)
@@ -67,6 +68,12 @@ scanner:
 	if cfg.Scanner.FuzzyThreshold != 0.9 {
 		t.Errorf("expected fuzzy_threshold 0.9, got %f", cfg.Scanner.FuzzyThreshold)
 	}
+	if !cfg.Scanner.IgnoreBootlegs {
+		t.Error("expected ignore_bootlegs true")
+	}
+	if cfg.Scanner.IncludeCompilations {
+		t.Error("expected include_compilations false")
+	}
 }
 
 func TestLoadConfig_Defaults(t *testing.T) {
@@ -339,83 +346,3 @@ func TestValidate_BoundaryPort(t *testing.T) {
 		})
 	}
 }
-
-func TestLoadConfig_SyncIntervalDefault(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "config.yaml")
-
-	yaml := `
-navidrome:
-  url: "http://localhost:4533"
-  user: "u"
-  password: "p"
-
-musicbrainz:
-  user_agent: "NaviWatcher/1.0 ( test@example.com )"
-`
-	if err := os.WriteFile(path, []byte(yaml), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	cfg, err := LoadConfig(path)
-	if err != nil {
-		t.Fatalf("LoadConfig returned error: %v", err)
-	}
-	if cfg.Sync.Interval != DefaultSyncInterval {
-		t.Errorf("expected default sync interval %v, got %v", DefaultSyncInterval, cfg.Sync.Interval)
-	}
-}
-
-func TestLoadConfig_SyncIntervalParsed(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "config.yaml")
-
-	yaml := `
-navidrome:
-  url: "http://localhost:4533"
-  user: "u"
-  password: "p"
-
-musicbrainz:
-  user_agent: "NaviWatcher/1.0 ( test@example.com )"
-
-sync:
-  interval: 30m
-`
-	if err := os.WriteFile(path, []byte(yaml), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	cfg, err := LoadConfig(path)
-	if err != nil {
-		t.Fatalf("LoadConfig returned error: %v", err)
-	}
-	if cfg.Sync.Interval != 30*time.Minute {
-		t.Errorf("expected sync interval 30m, got %v", cfg.Sync.Interval)
-	}
-}
-
-func TestLoadConfig_InvalidSyncInterval(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "config.yaml")
-
-	yaml := `
-navidrome:
-  url: "http://localhost:4533"
-  user: "u"
-  password: "p"
-
-musicbrainz:
-  user_agent: "NaviWatcher/1.0 ( test@example.com )"
-
-sync:
-  interval: -1s
-`
-	if err := os.WriteFile(path, []byte(yaml), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	if _, err := LoadConfig(path); err == nil {
-		t.Fatal("expected error for negative sync interval, got nil")
-	}
-}

internal/database/artist_settings.go

@@ -1,72 +1,28 @@
 package database
 
 import (
-	"database/sql"
-	"errors"
 	"fmt"
-	"time"
 )
 
 // GetArtistSettings retrieves an artist_settings row by ID.
 // Returns sql.ErrNoRows if the artist is not found.
 func GetArtistSettings(db *DB, id string) (*ArtistSettings, error) {
-	var (
-		s          ArtistSettings
-		mbid       sql.NullString
-		lastSynced sql.NullTime
-	)
+	var s ArtistSettings
 	err := db.Conn().QueryRow(
-		"SELECT id, name, mbid, ignore_singles, ignore_compilations, ignore_live, ignore_remix, monitored, last_synced FROM artist_settings WHERE id = ?",
+		"SELECT id, name, ignore_singles, ignore_compilations, monitored FROM artist_settings WHERE id = ?",
 		id,
-	).Scan(&s.ID, &s.Name, &mbid, &s.IgnoreSingles, &s.IgnoreCompilations, &s.IgnoreLive, &s.IgnoreRemix, &s.Monitored, &lastSynced)
+	).Scan(&s.ID, &s.Name, &s.IgnoreSingles, &s.IgnoreCompilations, &s.Monitored)
 	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, ErrArtistNotFound
-		}
 		return nil, err
 	}
-	s.MBID = mbid.String
-	if lastSynced.Valid {
-		s.LastSynced = lastSynced.Time
-	}
 	return &s, nil
 }
 
-// TouchArtistSynced records that the artist was synced at the given time. It
-// is used by the MusicBrainz pipeline to mark a successful sync (even one that
-// found zero release groups) so the cache TTL is honoured.
-func TouchArtistSynced(db DBer, artistID string, syncedAt time.Time) error {
-	_, err := db.Exec(
-		"UPDATE artist_settings SET last_synced = ? WHERE id = ?",
-		FormatCachedAt(syncedAt), artistID,
-	)
-	if err != nil {
-		return fmt.Errorf("touch artist synced: %w", err)
-	}
-	return nil
-}
-
-// SaveArtistSettings inserts or updates an artist_settings row. Columns not
-// present in the struct's intended set are preserved on conflict rather than
-// reset to their zero value: mbid and last_synced are carried over from the
-// existing row when the caller does not supply new values. This protects the
-// MusicBrainz-resolution cache and the sync TTL markers from being wiped on
-// every periodic artist sync.
+// SaveArtistSettings inserts or replaces an artist_settings row.
 func SaveArtistSettings(db *DB, settings *ArtistSettings) error {
-	_, err := db.Conn().Exec(`
-		INSERT INTO artist_settings (id, name, mbid, ignore_singles, ignore_compilations, ignore_live, ignore_remix, monitored, last_synced)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-		ON CONFLICT(id) DO UPDATE SET
-			name = excluded.name,
-			mbid = COALESCE(excluded.mbid, artist_settings.mbid),
-			ignore_singles = excluded.ignore_singles,
-			ignore_compilations = excluded.ignore_compilations,
-			ignore_live = excluded.ignore_live,
-			ignore_remix = excluded.ignore_remix,
-			monitored = excluded.monitored,
-			last_synced = COALESCE(excluded.last_synced, artist_settings.last_synced)
-	`,
-		settings.ID, settings.Name, nullIfEmpty(settings.MBID), settings.IgnoreSingles, settings.IgnoreCompilations, settings.IgnoreLive, settings.IgnoreRemix, settings.Monitored, nullIfEmptyTime(settings.LastSynced),
+	_, err := db.Conn().Exec(
+		"INSERT OR REPLACE INTO artist_settings (id, name, ignore_singles, ignore_compilations, monitored) VALUES (?, ?, ?, ?, ?)",
+		settings.ID, settings.Name, settings.IgnoreSingles, settings.IgnoreCompilations, settings.Monitored,
 	)
 	if err != nil {
 		return fmt.Errorf("save artist settings: %w", err)
@@ -74,28 +30,10 @@ func SaveArtistSettings(db *DB, settings *ArtistSettings) error {
 	return nil
 }
 
-// nullIfEmpty returns nil for an empty string so COALESCE-preserving columns
-// (e.g. mbid) keep their existing value when the caller supplies no new one.
-func nullIfEmpty(s string) interface{} {
-	if s == "" {
-		return nil
-	}
-	return s
-}
-
-// nullIfEmptyTime returns nil for zero time so COALESCE-preserving columns
-// (e.g. last_synced) keep their existing value when the caller supplies no new one.
-func nullIfEmptyTime(t time.Time) interface{} {
-	if t.IsZero() {
-		return nil
-	}
-	return t
-}
-
 // GetAllArtistSettings returns all rows from artist_settings.
 func GetAllArtistSettings(db *DB) ([]ArtistSettings, error) {
 	rows, err := db.Conn().Query(
-		"SELECT id, name, mbid, ignore_singles, ignore_compilations, ignore_live, ignore_remix, monitored, last_synced FROM artist_settings",
+		"SELECT id, name, ignore_singles, ignore_compilations, monitored FROM artist_settings",
 	)
 	if err != nil {
 		return nil, fmt.Errorf("query all artist settings: %w", err)
@@ -105,15 +43,9 @@ func GetAllArtistSettings(db *DB) ([]ArtistSettings, error) {
 	var results []ArtistSettings
 	for rows.Next() {
 		var s ArtistSettings
-		var mbid sql.NullString
-		var lastSynced sql.NullTime
-		if err := rows.Scan(&s.ID, &s.Name, &mbid, &s.IgnoreSingles, &s.IgnoreCompilations, &s.IgnoreLive, &s.IgnoreRemix, &s.Monitored, &lastSynced); err != nil {
+		if err := rows.Scan(&s.ID, &s.Name, &s.IgnoreSingles, &s.IgnoreCompilations, &s.Monitored); err != nil {
 			return nil, fmt.Errorf("scan artist settings: %w", err)
 		}
-		s.MBID = mbid.String
-		if lastSynced.Valid {
-			s.LastSynced = lastSynced.Time
-		}
 		results = append(results, s)
 	}
 	if err := rows.Err(); err != nil {
@@ -123,7 +55,7 @@ func GetAllArtistSettings(db *DB) ([]ArtistSettings, error) {
 }
 
 // UpdateArtistSettings updates specific fields of an artist_settings row by ID.
-// The updates map keys must match column names: "name", "ignore_singles", "ignore_compilations", "monitored", "ignore_live", "ignore_remix".
+// The updates map keys must match column names: "name", "ignore_singles", "ignore_compilations", "monitored".
 func UpdateArtistSettings(db *DB, id string, updates map[string]interface{}) error {
 	if len(updates) == 0 {
 		return fmt.Errorf("no updates provided")
@@ -142,12 +74,6 @@ func UpdateArtistSettings(db *DB, id string, updates map[string]interface{}) err
 			}
 			setClause += "name = ?"
 			args = append(args, val)
-		case "mbid":
-			if setClause != "" {
-				setClause += ", "
-			}
-			setClause += "mbid = ?"
-			args = append(args, val)
 		case "ignore_singles":
 			if setClause != "" {
 				setClause += ", "
@@ -160,18 +86,6 @@ func UpdateArtistSettings(db *DB, id string, updates map[string]interface{}) err
 			}
 			setClause += "ignore_compilations = ?"
 			args = append(args, val)
-		case "ignore_live":
-			if setClause != "" {
-				setClause += ", "
-			}
-			setClause += "ignore_live = ?"
-			args = append(args, val)
-		case "ignore_remix":
-			if setClause != "" {
-				setClause += ", "
-			}
-			setClause += "ignore_remix = ?"
-			args = append(args, val)
 		case "monitored":
 			if setClause != "" {
 				setClause += ", "

internal/database/artist_settings_test.go

@@ -3,7 +3,6 @@ package database
 import (
 	"database/sql"
 	"testing"
-	"time"
 )
 
 // TestGetArtistSettings_Found verifies retrieving an existing artist.
@@ -45,7 +44,7 @@ func TestGetArtistSettings_Found(t *testing.T) {
 	}
 }
 
-// TestGetArtistSettings_NotFound verifies that a missing artist returns ErrArtistNotFound.
+// TestGetArtistSettings_NotFound verifies that a missing artist returns sql.ErrNoRows.
 func TestGetArtistSettings_NotFound(t *testing.T) {
 	db, err := New(":memory:")
 	if err != nil {
@@ -54,8 +53,8 @@ func TestGetArtistSettings_NotFound(t *testing.T) {
 	defer db.Close()
 
 	_, err = GetArtistSettings(db, "nonexistent")
-	if err != ErrArtistNotFound {
-		t.Errorf("expected ErrArtistNotFound, got %v", err)
+	if err != sql.ErrNoRows {
+		t.Errorf("expected sql.ErrNoRows, got %v", err)
 	}
 }
 
@@ -306,482 +305,3 @@ func TestUpdateArtistSettings_EmptyUpdates(t *testing.T) {
 		t.Error("expected error for empty updates, got nil")
 	}
 }
-
-// TestMigration008_MbidColumnExists verifies the 008 migration adds the mbid
-// column and that rows created before resolution have a NULL/empty MBID.
-func TestMigration008_MbidColumnExists(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Insert a row without supplying mbid (simulates a pre-resolution row).
-	if _, err := db.Conn().Exec(
-		"INSERT INTO artist_settings (id, name) VALUES (?, ?)",
-		"artist-1", "No MBID Yet",
-	); err != nil {
-		t.Fatalf("insert without mbid: %v", err)
-	}
-
-	var mbid sql.NullString
-	if err := db.Conn().QueryRow(
-		"SELECT mbid FROM artist_settings WHERE id = ?", "artist-1",
-	).Scan(&mbid); err != nil {
-		t.Fatalf("query mbid: %v", err)
-	}
-	if mbid.Valid && mbid.String != "" {
-		t.Errorf("expected empty mbid for pre-resolution row, got %q", mbid.String)
-	}
-}
-
-// TestArtistSettings_MbidRoundTrip verifies Save/Get round-trips an MBID,
-// and that an empty MBID is preserved (not overwritten with garbage).
-func TestArtistSettings_MbidRoundTrip(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	s := &ArtistSettings{
-		ID:    "artist-1",
-		Name:  "Test Artist",
-		MBID:  "f27e6623-8771-4a2e-8dcb-6c8b1a4f8b9a",
-		Monitored: true,
-	}
-	if err := SaveArtistSettings(db, s); err != nil {
-		t.Fatalf("SaveArtistSettings() error: %v", err)
-	}
-
-	got, err := GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-	if got.MBID != s.MBID {
-		t.Errorf("expected MBID %q, got %q", s.MBID, got.MBID)
-	}
-}
-
-// TestArtistSettings_MbidEmptyAllowed verifies an artist can be saved and
-// retrieved with no MBID set (lazy resolution not yet performed).
-func TestArtistSettings_MbidEmptyAllowed(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	s := &ArtistSettings{ID: "artist-1", Name: "No MBID", Monitored: true}
-	if err := SaveArtistSettings(db, s); err != nil {
-		t.Fatalf("SaveArtistSettings() error: %v", err)
-	}
-
-	got, err := GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-	if got.MBID != "" {
-		t.Errorf("expected empty MBID, got %q", got.MBID)
-	}
-}
-
-// TestArtistSettings_MbidUpdatePersists verifies UpdateArtistSettings can set
-// and clear the MBID column.
-func TestArtistSettings_MbidUpdatePersists(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	if err := SaveArtistSettings(db, &ArtistSettings{ID: "artist-1", Name: "Test", Monitored: true}); err != nil {
-		t.Fatalf("SaveArtistSettings() error: %v", err)
-	}
-
-	mbid := "f27e6623-8771-4a2e-8dcb-6c8b1a4f8b9a"
-	if err := UpdateArtistSettings(db, "artist-1", map[string]interface{}{"mbid": mbid}); err != nil {
-		t.Fatalf("UpdateArtistSettings(set mbid) error: %v", err)
-	}
-	got, err := GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-	if got.MBID != mbid {
-		t.Errorf("expected MBID %q after set, got %q", mbid, got.MBID)
-	}
-
-	// Clear it again.
-	if err := UpdateArtistSettings(db, "artist-1", map[string]interface{}{"mbid": ""}); err != nil {
-		t.Fatalf("UpdateArtistSettings(clear mbid) error: %v", err)
-	}
-	got, err = GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-	if got.MBID != "" {
-		t.Errorf("expected empty MBID after clear, got %q", got.MBID)
-	}
-}
-
-// TestArtistSettings_MbidInGetAll verifies GetAllArtistSettings returns the
-// MBID field for all rows.
-func TestArtistSettings_MbidInGetAll(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	artists := []ArtistSettings{
-		{ID: "a1", Name: "Artist One", MBID: "mbid-1", Monitored: true},
-		{ID: "a2", Name: "Artist Two", Monitored: true},
-	}
-	for _, a := range artists {
-		if err := SaveArtistSettings(db, &a); err != nil {
-			t.Fatalf("SaveArtistSettings(%s) error: %v", a.ID, err)
-		}
-	}
-
-	results, err := GetAllArtistSettings(db)
-	if err != nil {
-		t.Fatalf("GetAllArtistSettings() error: %v", err)
-	}
-	if len(results) != 2 {
-		t.Fatalf("expected 2 results, got %d", len(results))
-	}
-	byID := make(map[string]ArtistSettings)
-	for _, r := range results {
-		byID[r.ID] = r
-	}
-	if byID["a1"].MBID != "mbid-1" {
-		t.Errorf("artist a1: expected MBID 'mbid-1', got %q", byID["a1"].MBID)
-	}
-	if byID["a2"].MBID != "" {
-		t.Errorf("artist a2: expected empty MBID, got %q", byID["a2"].MBID)
-	}
-}
-
-// TestSaveArtistSettings_LastSyncedPreserved verifies that last_synced is preserved
-// on update when not explicitly provided in the update.
-func TestSaveArtistSettings_LastSyncedPreserved(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Set a fixed time for testing
-	fixedTime := time.Date(2023, 1, 1, 12, 0, 0, 0, time.UTC)
-
-	// Insert initial row with a specific last_synced time
-	s1 := &ArtistSettings{
-		ID:                 "artist-1",
-		Name:               "Original Name",
-		IgnoreSingles:      false,
-		IgnoreCompilations: false,
-		Monitored:          true,
-		LastSynced:         fixedTime,
-	}
-	if err := SaveArtistSettings(db, s1); err != nil {
-		t.Fatalf("first SaveArtistSettings() error: %v", err)
-	}
-
-	// Verify it was inserted with correct last_synced
-	got, err := GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-	if got.LastSynced != fixedTime {
-		t.Fatalf("expected last_synced %v, got %v", fixedTime, got.LastSynced)
-	}
-
-	// Update the row with new values but without specifying last_synced
-	// This should preserve the original last_synced value
-	s2 := &ArtistSettings{
-		ID:                 "artist-1",
-		Name:               "Updated Name",
-		IgnoreSingles:      true,
-		IgnoreCompilations: true,
-		Monitored:          false,
-		// Note: LastSynced is intentionally left as zero value
-	}
-	if err := SaveArtistSettings(db, s2); err != nil {
-		t.Fatalf("second SaveArtistSettings() error: %v", err)
-	}
-
-	got, err = GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-	if got.Name != "Updated Name" {
-		t.Errorf("expected Name 'Updated Name', got %q", got.Name)
-	}
-	if !got.IgnoreSingles {
-		t.Error("expected IgnoreSingles true")
-	}
-	if !got.IgnoreCompilations {
-		t.Error("expected IgnoreCompilations true")
-	}
-	if got.Monitored {
-		t.Error("expected Monitored false")
-	}
-	// Most importantly: last_synced should be preserved
-	if got.LastSynced != fixedTime {
-		t.Errorf("expected last_synced to be preserved as %v, got %v", fixedTime, got.LastSynced)
-	}
-}
-
-// TestSaveArtistSettings_LastSyncedUpdated verifies that last_synced can be updated
-// when explicitly provided.
-func TestSaveArtistSettings_LastSyncedUpdated(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Set fixed times for testing
-	oldTime := time.Date(2023, 1, 1, 12, 0, 0, 0, time.UTC)
-	newTime := time.Date(2023, 12, 31, 23, 59, 59, 0, time.UTC)
-
-	// Insert initial row
-	s1 := &ArtistSettings{
-		ID:                 "artist-1",
-		Name:               "Original Name",
-		IgnoreSingles:      false,
-		IgnoreCompilations: false,
-		Monitored:          true,
-		LastSynced:         oldTime,
-	}
-	if err := SaveArtistSettings(db, s1); err != nil {
-		t.Fatalf("first SaveArtistSettings() error: %v", err)
-	}
-
-	// Update the row with a new last_synced time
-	s2 := &ArtistSettings{
-		ID:                 "artist-1",
-		Name:               "Updated Name",
-		IgnoreSingles:      true,
-		IgnoreCompilations: true,
-		Monitored:          false,
-		LastSynced:         newTime,
-	}
-	if err := SaveArtistSettings(db, s2); err != nil {
-		t.Fatalf("second SaveArtistSettings() error: %v", err)
-	}
-
-	got, err := GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-	if got.Name != "Updated Name" {
-		t.Errorf("expected Name 'Updated Name', got %q", got.Name)
-	}
-	if !got.IgnoreSingles {
-		t.Error("expected IgnoreSingles true")
-	}
-	if !got.IgnoreCompilations {
-		t.Error("expected IgnoreCompilations true")
-	}
-	if got.Monitored {
-		t.Error("expected Monitored false")
-	}
-	// last_synced should be updated to the new value
-	if got.LastSynced != newTime {
-		t.Errorf("expected last_synced to be updated to %v, got %v", newTime, got.LastSynced)
-	}
-}
-
-// TestGetArtistSettings_FoundWithNewFields verifies retrieving an existing artist with new fields.
-func TestGetArtistSettings_FoundWithNewFields(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Insert a row with all fields including new ones
-	_, err = db.Conn().Exec(
-		"INSERT INTO artist_settings (id, name, mbid, ignore_singles, ignore_compilations, ignore_live, ignore_remix, monitored, last_synced) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
-		"artist-1", "Test Artist", "", true, false, true, false, true, time.Now(),
-	)
-	if err != nil {
-		t.Fatalf("insert: %v", err)
-	}
-
-	s, err := GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-
-	if s.ID != "artist-1" {
-		t.Errorf("expected ID 'artist-1', got %q", s.ID)
-	}
-	if s.Name != "Test Artist" {
-		t.Errorf("expected Name 'Test Artist', got %q", s.Name)
-	}
-	if !s.IgnoreSingles {
-		t.Error("expected IgnoreSingles true")
-	}
-	if s.IgnoreCompilations {
-		t.Error("expected IgnoreCompilations false")
-	}
-	if !s.IgnoreLive {
-		t.Error("expected IgnoreLive true")
-	}
-	if s.IgnoreRemix {
-		t.Error("expected IgnoreRemix false")
-	}
-	if !s.Monitored {
-		t.Error("expected Monitored true")
-	}
-}
-
-// TestSaveArtistSettings_UpdateNewFields verifies that SaveArtistSettings works with new fields.
-func TestSaveArtistSettings_UpdateNewFields(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Insert initial row
-	s1 := &ArtistSettings{
-		ID:                 "artist-1",
-		Name:               "Original Name",
-		IgnoreSingles:      false,
-		IgnoreCompilations: false,
-		IgnoreLive:         false,
-		IgnoreRemix:        false,
-		Monitored:          true,
-	}
-	if err := SaveArtistSettings(db, s1); err != nil {
-		t.Fatalf("first SaveArtistSettings() error: %v", err)
-	}
-
-	// Update with new fields
-	s2 := &ArtistSettings{
-		ID:                 "artist-1",
-		Name:               "Updated Name",
-		IgnoreSingles:      true,
-		IgnoreCompilations: true,
-		IgnoreLive:         true,
-		IgnoreRemix:        true,
-		Monitored:          false,
-	}
-	if err := SaveArtistSettings(db, s2); err != nil {
-		t.Fatalf("second SaveArtistSettings() error: %v", err)
-	}
-
-	got, err := GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-	if got.Name != "Updated Name" {
-		t.Errorf("expected Name 'Updated Name', got %q", got.Name)
-	}
-	if !got.IgnoreSingles {
-		t.Error("expected IgnoreSingles true")
-	}
-	if !got.IgnoreCompilations {
-		t.Error("expected IgnoreCompilations true")
-	}
-	if !got.IgnoreLive {
-		t.Error("expected IgnoreLive true")
-	}
-	if !got.IgnoreRemix {
-		t.Error("expected IgnoreRemix false")
-	}
-	if got.Monitored {
-		t.Error("expected Monitored false")
-	}
-}
-
-// TestUpdateArtistSettings_NewFields verifies updating the new fields works.
-func TestUpdateArtistSettings_NewFields(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Insert initial row
-	s := &ArtistSettings{
-		ID:                 "artist-1",
-		Name:               "Original",
-		IgnoreSingles:      false,
-		IgnoreCompilations: false,
-		IgnoreLive:         false,
-		IgnoreRemix:        false,
-		Monitored:          true,
-	}
-	if err := SaveArtistSettings(db, s); err != nil {
-		t.Fatalf("SaveArtistSettings() error: %v", err)
-	}
-
-	// Update only new fields
-	updates := map[string]interface{}{
-		"ignore_live":  true,
-		"ignore_remix": true,
-	}
-	if err := UpdateArtistSettings(db, "artist-1", updates); err != nil {
-		t.Fatalf("UpdateArtistSettings() error: %v", err)
-	}
-
-	got, err := GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-	if !got.IgnoreLive {
-		t.Error("expected IgnoreLive true")
-	}
-	if !got.IgnoreRemix {
-		t.Error("expected IgnoreRemix true")
-	}
-	// Unchanged fields should remain
-	if got.IgnoreSingles != false {
-		t.Error("expected IgnoreSingles unchanged (false)")
-	}
-	if got.IgnoreCompilations != false {
-		t.Error("expected IgnoreCompilations unchanged (false)")
-	}
-	if !got.Monitored {
-		t.Error("expected Monitored unchanged (true)")
-	}
-}
-
-// TestUpdateArtistSettings_NewFieldsNotFound verifies updating a nonexistent artist returns error.
-func TestUpdateArtistSettings_NewFieldsNotFound(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	updates := map[string]interface{}{"ignore_live": true}
-	err = UpdateArtistSettings(db, "nonexistent", updates)
-	if err == nil {
-		t.Error("expected error for nonexistent artist, got nil")
-	}
-}
-
-// TestUpdateArtistSettings_InvalidColumnNewFields verifies unknown columns are rejected.
-func TestUpdateArtistSettings_InvalidColumnNewFields(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	s := &ArtistSettings{ID: "artist-1", Name: "Test"}
-	if err := SaveArtistSettings(db, s); err != nil {
-		t.Fatalf("SaveArtistSettings() error: %v", err)
-	}
-
-	updates := map[string]interface{}{"invalid_col": "value"}
-	err = UpdateArtistSettings(db, "artist-1", updates)
-	if err == nil {
-		t.Error("expected error for invalid column, got nil")
-	}
-}

internal/database/database.go

@@ -2,9 +2,7 @@ package database
 
 import (
 	"database/sql"
-	"errors"
 	"fmt"
-	"strings"
 	"time"
 
 	_ "github.com/mattn/go-sqlite3"
@@ -15,63 +13,30 @@ type DB struct {
 	conn *sql.DB
 }
 
-// DBer is the minimal query interface satisfied by both *sql.DB and *sql.Tx,
-// so callers can run statements inside or outside a transaction.
-type DBer interface {
-	Exec(query string, args ...interface{}) (sql.Result, error)
-}
-
-// ErrArtistNotFound is returned by artist lookups when no row matches the given
-// ID. It is a sentinel so callers (e.g. the web UI) can distinguish "missing"
-// from other errors.
-var ErrArtistNotFound = errors.New("artist not found")
-
-// ErrReleaseNotFound is returned by SetReleaseIgnored when no external_release
-// row matches the given RGID (e.g. it was pruned by a concurrent re-sync). It
-// is a sentinel so callers (e.g. the web UI) can treat it as benign.
-var ErrReleaseNotFound = errors.New("release not found")
-
 // New opens a SQLite database at dbPath and runs schema migrations.
 func New(dbPath string) (*DB, error) {
-	// The _foreign_keys=on DSN parameter enables foreign key enforcement on
-	// EVERY connection in the pool. A one-off "PRAGMA foreign_keys=ON" executed
-	// on the pooled *sql.DB only applies to the first connection and is lost on
-	// connections opened later by the pool, silently disabling the safety net.
-	// A plain ":memory:" database is private to the connection that opened it,
-	// so a pool of N connections would give N separate empty databases and
-	// migrations would appear missing on some. Limiting the pool to a single
-	// connection keeps one in-memory database per New() call, which is correct
-	// for both tests (isolated) and the single-process production service.
-	// Append the foreign_keys pragma via net/url so a caller-supplied path that
-	// already contains a query string is not silently broken.
-	dsn := dbPath
-	if !strings.Contains(dsn, "?") {
-		dsn += "?"
-	} else {
-		dsn += "&"
-	}
-	dsn += "_foreign_keys=on"
-	conn, err := sql.Open("sqlite3", dsn)
+	conn, err := sql.Open("sqlite3", dbPath)
 	if err != nil {
 		return nil, fmt.Errorf("open database: %w", err)
 	}
-	if dbPath == ":memory:" {
-		conn.SetMaxOpenConns(1)
-	} else {
-		// Enable WAL mode for better concurrent read performance. WAL is a
-		// no-op on in-memory databases (they always use the MEMORY journal), so
-		// skip it there to avoid misleading configuration.
+
+	// Enable WAL mode for better concurrent read performance.
 	if _, err := conn.Exec("PRAGMA journal_mode=WAL"); err != nil {
 		conn.Close()
 		return nil, fmt.Errorf("set WAL mode: %w", err)
 	}
 
+	// Enable foreign key enforcement.
+	if _, err := conn.Exec("PRAGMA foreign_keys=ON"); err != nil {
+		conn.Close()
+		return nil, fmt.Errorf("enable foreign keys: %w", err)
+	}
+
 	// Set busy timeout to handle concurrent write contention.
 	if _, err := conn.Exec("PRAGMA busy_timeout=5000"); err != nil {
 		conn.Close()
 		return nil, fmt.Errorf("set busy timeout: %w", err)
 	}
-	}
 
 	db := &DB{conn: conn}
 	if err := db.migrate(); err != nil {
@@ -92,11 +57,6 @@ func (db *DB) Conn() *sql.DB {
 	return db.conn
 }
 
-// Begin starts a new database transaction.
-func (db *DB) Begin() (*sql.Tx, error) {
-	return db.conn.Begin()
-}
-
 // migrate runs all pending schema migrations in order.
 func (db *DB) migrate() error {
 	// Create the migrations tracking table first, unconditionally.
@@ -134,47 +94,13 @@ func (db *DB) migrate() error {
 			);`,
 		},
 		{
-			name: "003_create_local_albums",
-			sql: `CREATE TABLE IF NOT EXISTS local_albums (
-				id TEXT PRIMARY KEY,
-				artist_id TEXT NOT NULL REFERENCES artist_settings(id),
-				title TEXT NOT NULL
-			);
-			CREATE INDEX IF NOT EXISTS idx_local_albums_artist_id ON local_albums(artist_id);`,
-		},
-		{
-			name: "004_create_notifications_sent",
+			name: "003_create_notifications_sent",
 			sql: `CREATE TABLE IF NOT EXISTS notifications_sent (
 				rgid TEXT NOT NULL REFERENCES external_releases(rgid),
 				sent_at DATETIME DEFAULT CURRENT_TIMESTAMP,
 				PRIMARY KEY (rgid, sent_at)
 			);`,
 		},
-		{
-			name: "005_add_cached_at_to_external_releases",
-			sql:  `ALTER TABLE external_releases ADD COLUMN cached_at DATETIME;`,
-		},
-		{
-			name: "006_add_secondary_types_to_external_releases",
-			sql:  `ALTER TABLE external_releases ADD COLUMN secondary_types TEXT;`,
-		},
-		{
-			name: "007_index_external_releases_artist_id",
-			sql:  `CREATE INDEX IF NOT EXISTS idx_external_releases_artist_id ON external_releases(artist_id);`,
-		},
-		{
-			name: "008_add_mbid_to_artist_settings",
-			sql:  `ALTER TABLE artist_settings ADD COLUMN mbid TEXT;`,
-		},
-		{
-			name: "009_add_last_synced_to_artist_settings",
-			sql:  `ALTER TABLE artist_settings ADD COLUMN last_synced DATETIME;`,
-		},
-		{
-			name: "010_add_ignore_live_ignore_remix_to_artist_settings",
-			sql:  `ALTER TABLE artist_settings ADD COLUMN ignore_live BOOLEAN DEFAULT 0;
-				  ALTER TABLE artist_settings ADD COLUMN ignore_remix BOOLEAN DEFAULT 0;`,
-		},
 	}
 
 	for _, m := range migrations {
@@ -219,24 +145,14 @@ func (db *DB) isMigrationApplied(name string) (bool, error) {
 	return count > 0, nil
 }
 
+
 // ArtistSettings represents a row in the artist_settings table.
 type ArtistSettings struct {
 	ID                 string `json:"id"`
 	Name               string `json:"name"`
-	MBID               string    `json:"mbid"`
 	IgnoreSingles      bool   `json:"ignore_singles"`
 	IgnoreCompilations bool   `json:"ignore_compilations"`
-	IgnoreLive         bool      `json:"ignore_live"`
-	IgnoreRemix        bool      `json:"ignore_remix"`
 	Monitored          bool   `json:"monitored"`
-	LastSynced         time.Time `json:"last_synced"`
-}
-
-// LocalAlbum represents a row in the local_albums table.
-type LocalAlbum struct {
-	ID       string `json:"id"`
-	ArtistID string `json:"artist_id"`
-	Title    string `json:"title"`
 }
 
 // ExternalRelease represents a row in the external_releases table.
@@ -247,8 +163,6 @@ type ExternalRelease struct {
 	Type        string `json:"type"`
 	ReleaseDate string `json:"release_date"`
 	IsIgnored   bool   `json:"is_ignored"`
-	CachedAt       time.Time `json:"cached_at"`
-	SecondaryTypes []string  `json:"secondary_types"`
 }
 
 // NotificationSent represents a row in the notifications_sent table.

internal/database/database_test.go

@@ -16,7 +16,6 @@ func TestNew_InitializationAndSchema(t *testing.T) {
 		"_migrations",
 		"artist_settings",
 		"external_releases",
-		"local_albums",
 		"notifications_sent",
 	}
 
@@ -31,7 +30,7 @@ func TestNew_InitializationAndSchema(t *testing.T) {
 	}
 }
 
-// TestNew_MigrationIdempotency verifies that calling New() twice (via migrate) does not fail.
+// TestNew_MigrationIdempency verifies that calling New() twice (via migrate) does not fail.
 func TestNew_MigrationIdempotency(t *testing.T) {
 	db, err := New(":memory:")
 	if err != nil {
@@ -47,14 +46,14 @@ func TestNew_MigrationIdempotency(t *testing.T) {
 	// Verify tables still exist.
 	var count int
 	err = db.Conn().QueryRow(
-		"SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name IN (?,?,?,?,?)",
-		"_migrations", "artist_settings", "external_releases", "local_albums", "notifications_sent",
+		"SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name IN (?,?,?,?)",
+		"_migrations", "artist_settings", "external_releases", "notifications_sent",
 	).Scan(&count)
 	if err != nil {
 		t.Fatalf("query error: %v", err)
 	}
-	if count != 5 {
-		t.Errorf("expected 5 tables, got %d", count)
+	if count != 4 {
+		t.Errorf("expected 4 tables, got %d", count)
 	}
 
 	db.Close()
@@ -89,27 +88,26 @@ func TestArtistSettingsSchema(t *testing.T) {
 
 	// Insert a row to verify column names and types.
 	_, err = db.Conn().Exec(
-		"INSERT INTO artist_settings (id, name, ignore_singles, ignore_compilations, ignore_live, ignore_remix, monitored) VALUES (?, ?, ?, ?, ?, ?, ?)",
-		"artist-1", "Test Artist", true, false, false, false, true,
+		"INSERT INTO artist_settings (id, name, ignore_singles, ignore_compilations, monitored) VALUES (?, ?, ?, ?, ?)",
+		"artist-1", "Test Artist", true, false, true,
 	)
 	if err != nil {
 		t.Fatalf("insert into artist_settings: %v", err)
 	}
 
 	var id, name string
-	var ignoreLive, ignoreRemix bool
 	var ignoreSingles, ignoreCompilations, monitored bool
 	err = db.Conn().QueryRow(
-		"SELECT id, name, ignore_singles, ignore_compilations, ignore_live, ignore_remix, monitored FROM artist_settings WHERE id = ?",
+		"SELECT id, name, ignore_singles, ignore_compilations, monitored FROM artist_settings WHERE id = ?",
 		"artist-1",
-	).Scan(&id, &name, &ignoreSingles, &ignoreCompilations, &ignoreLive, &ignoreRemix, &monitored)
+	).Scan(&id, &name, &ignoreSingles, &ignoreCompilations, &monitored)
 	if err != nil {
 		t.Fatalf("select from artist_settings: %v", err)
 	}
 
-	if id != "artist-1" || name != "Test Artist" || !ignoreSingles || ignoreCompilations || ignoreLive || ignoreRemix || !monitored {
-		t.Errorf("unexpected row values: id=%q name=%q ignoreSingles=%v ignoreCompilations=%v ignoreLive=%v ignoreRemix=%v monitored=%v",
-			id, name, ignoreSingles, ignoreCompilations, ignoreLive, ignoreRemix, monitored)
+	if id != "artist-1" || name != "Test Artist" || !ignoreSingles || ignoreCompilations || !monitored {
+		t.Errorf("unexpected row values: id=%q name=%q ignoreSingles=%v ignoreCompilations=%v monitored=%v",
+			id, name, ignoreSingles, ignoreCompilations, monitored)
 	}
 }
 
@@ -206,8 +204,8 @@ func TestMigrationTracking(t *testing.T) {
 		t.Fatalf("query migrations count: %v", err)
 	}
 
-	// We now have 10 recorded migrations.
-	if count != 10 {
-		t.Errorf("expected 10 applied migrations, got %d", count)
+	// We have 3 recorded migrations: artist_settings, external_releases, notifications_sent.
+	if count != 3 {
+		t.Errorf("expected 3 applied migrations, got %d", count)
 	}
 }

internal/database/external_releases.go

@@ -1,78 +1,28 @@
 package database
 
 import (
-	"database/sql"
 	"fmt"
-	"strings"
-	"time"
-
-	_ "github.com/mattn/go-sqlite3"
 )
 
-// utcLayout is the canonical layout for the cached_at column. go-sqlite3
-// serializes a time.Time as RFC3339, which does not compare correctly against
-// the space-separated cutoff used by the cache query. Storing this layout keeps
-// the lexicographic comparison in GetExternalReleasesByArtistWithCache valid.
-const utcLayout = "2006-01-02 15:04:05"
-
-// FormatCachedAt renders a timestamp in the canonical UTC layout for storage.
-// A zero time yields nil so the column is left NULL.
-func FormatCachedAt(t time.Time) interface{} {
-	if t.IsZero() {
-		return nil
-	}
-	return t.UTC().Format(utcLayout)
-}
-
-// JoinSecondaryTypes renders a slice of secondary types as a comma-separated
-// string for storage in the secondary_types TEXT column (empty when none).
-func JoinSecondaryTypes(types []string) string {
-	return strings.Join(types, ",")
-}
-
-// splitSecondaryTypes parses the comma-separated secondary_types column back
-// into a slice. A NULL/empty column yields an empty slice.
-func splitSecondaryTypes(s string) []string {
-	if s == "" {
-		return nil
-	}
-	parts := strings.Split(s, ",")
-	out := make([]string, 0, len(parts))
-	for _, p := range parts {
-		if p != "" {
-			out = append(out, p)
-		}
-	}
-	return out
-}
-
 // GetExternalRelease retrieves an external_release row by RGID.
+// Returns sql.ErrNoRows if the release is not found.
 func GetExternalRelease(db *DB, rgid string) (*ExternalRelease, error) {
 	var r ExternalRelease
-	var cachedAt sql.NullTime
-	var secondaryTypes sql.NullString
 	err := db.Conn().QueryRow(
-		"SELECT rgid, artist_id, title, COALESCE(type,''), COALESCE(release_date,''), is_ignored, cached_at, secondary_types FROM external_releases WHERE rgid = ?",
+		"SELECT rgid, artist_id, title, type, release_date, is_ignored FROM external_releases WHERE rgid = ?",
 		rgid,
-	).Scan(&r.RGID, &r.ArtistID, &r.Title, &r.Type, &r.ReleaseDate, &r.IsIgnored, &cachedAt, &secondaryTypes)
+	).Scan(&r.RGID, &r.ArtistID, &r.Title, &r.Type, &r.ReleaseDate, &r.IsIgnored)
 	if err != nil {
-		return nil, fmt.Errorf("get external release: %w", err)
-	}
-	if cachedAt.Valid {
-		r.CachedAt = cachedAt.Time
-	}
-	if secondaryTypes.Valid {
-		r.SecondaryTypes = splitSecondaryTypes(secondaryTypes.String)
+		return nil, err
 	}
 	return &r, nil
 }
 
 // SaveExternalRelease inserts or replaces an external_release row.
 func SaveExternalRelease(db *DB, release *ExternalRelease) error {
-	var cachedAt interface{} = FormatCachedAt(release.CachedAt)
 	_, err := db.Conn().Exec(
-		"INSERT OR REPLACE INTO external_releases (rgid, artist_id, title, type, release_date, is_ignored, cached_at, secondary_types) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-		release.RGID, release.ArtistID, release.Title, release.Type, release.ReleaseDate, release.IsIgnored, cachedAt, JoinSecondaryTypes(release.SecondaryTypes),
+		"INSERT OR REPLACE INTO external_releases (rgid, artist_id, title, type, release_date, is_ignored) VALUES (?, ?, ?, ?, ?, ?)",
+		release.RGID, release.ArtistID, release.Title, release.Type, release.ReleaseDate, release.IsIgnored,
 	)
 	if err != nil {
 		return fmt.Errorf("save external release: %w", err)
@@ -83,7 +33,7 @@ func SaveExternalRelease(db *DB, release *ExternalRelease) error {
 // GetExternalReleasesByArtist returns all external_release rows for a given artist_id.
 func GetExternalReleasesByArtist(db *DB, artistID string) ([]ExternalRelease, error) {
 	rows, err := db.Conn().Query(
-		"SELECT rgid, artist_id, title, COALESCE(type,''), COALESCE(release_date,''), is_ignored, cached_at, secondary_types FROM external_releases WHERE artist_id = ?",
+		"SELECT rgid, artist_id, title, type, release_date, is_ignored FROM external_releases WHERE artist_id = ?",
 		artistID,
 	)
 	if err != nil {
@@ -94,17 +44,9 @@ func GetExternalReleasesByArtist(db *DB, artistID string) ([]ExternalRelease, er
 	var results []ExternalRelease
 	for rows.Next() {
 		var r ExternalRelease
-		var cachedAt sql.NullTime
-		var secondaryTypes sql.NullString
-		if err := rows.Scan(&r.RGID, &r.ArtistID, &r.Title, &r.Type, &r.ReleaseDate, &r.IsIgnored, &cachedAt, &secondaryTypes); err != nil {
+		if err := rows.Scan(&r.RGID, &r.ArtistID, &r.Title, &r.Type, &r.ReleaseDate, &r.IsIgnored); err != nil {
 			return nil, fmt.Errorf("scan external release: %w", err)
 		}
-		if cachedAt.Valid {
-			r.CachedAt = cachedAt.Time
-		}
-		if secondaryTypes.Valid {
-			r.SecondaryTypes = splitSecondaryTypes(secondaryTypes.String)
-		}
 		results = append(results, r)
 	}
 	if err := rows.Err(); err != nil {
@@ -116,7 +58,7 @@ func GetExternalReleasesByArtist(db *DB, artistID string) ([]ExternalRelease, er
 // GetIgnoredReleases returns all external_release rows where is_ignored = 1.
 func GetIgnoredReleases(db *DB) ([]ExternalRelease, error) {
 	rows, err := db.Conn().Query(
-		"SELECT rgid, artist_id, title, COALESCE(type,''), COALESCE(release_date,''), is_ignored, cached_at, secondary_types FROM external_releases WHERE is_ignored = 1",
+		"SELECT rgid, artist_id, title, type, release_date, is_ignored FROM external_releases WHERE is_ignored = 1",
 	)
 	if err != nil {
 		return nil, fmt.Errorf("query ignored releases: %w", err)
@@ -126,17 +68,9 @@ func GetIgnoredReleases(db *DB) ([]ExternalRelease, error) {
 	var results []ExternalRelease
 	for rows.Next() {
 		var r ExternalRelease
-		var cachedAt sql.NullTime
-		var secondaryTypes sql.NullString
-		if err := rows.Scan(&r.RGID, &r.ArtistID, &r.Title, &r.Type, &r.ReleaseDate, &r.IsIgnored, &cachedAt, &secondaryTypes); err != nil {
+		if err := rows.Scan(&r.RGID, &r.ArtistID, &r.Title, &r.Type, &r.ReleaseDate, &r.IsIgnored); err != nil {
 			return nil, fmt.Errorf("scan ignored release: %w", err)
 		}
-		if cachedAt.Valid {
-			r.CachedAt = cachedAt.Time
-		}
-		if secondaryTypes.Valid {
-			r.SecondaryTypes = splitSecondaryTypes(secondaryTypes.String)
-		}
 		results = append(results, r)
 	}
 	if err := rows.Err(); err != nil {
@@ -160,96 +94,8 @@ func SetReleaseIgnored(db *DB, rgid string, ignored bool) error {
 		return fmt.Errorf("rows affected: %w", err)
 	}
 	if rowsAffected == 0 {
-		return fmt.Errorf("%w: %s", ErrReleaseNotFound, rgid)
+		return fmt.Errorf("release not found: %s", rgid)
 	}
 
 	return nil
 }
-
-// ArtistCacheFresh reports whether the artist was synced within the TTL. A hit
-// requires a fresh external_releases row (covers pre-seeded/non-empty caches)
-// OR a fresh artist_settings.last_synced (covers empty discographies, which
-// store no external_releases rows but are still marked as synced). Either
-// signal means we should not re-fetch from MusicBrainz.
-func ArtistCacheFresh(db *DB, artistID string, ttl time.Duration) (bool, error) {
-	if ttl <= 0 {
-		return false, nil
-	}
-	cutoff := time.Now().UTC().Add(-ttl).Format(utcLayout)
-	var dummy int
-	err := db.Conn().QueryRow(
-		"SELECT 1 FROM external_releases WHERE artist_id = ? AND cached_at >= ? LIMIT 1",
-		artistID, cutoff,
-	).Scan(&dummy)
-	if err == nil {
-		return true, nil
-	}
-	if err != sql.ErrNoRows {
-		return false, fmt.Errorf("check artist cache freshness (releases): %w", err)
-	}
-
-	// Fall back to the per-artist last_synced marker (set even on empty syncs).
-	err = db.Conn().QueryRow(
-		"SELECT 1 FROM artist_settings WHERE id = ? AND last_synced >= ? LIMIT 1",
-		artistID, cutoff,
-	).Scan(&dummy)
-	if err == nil {
-		return true, nil
-	}
-	if err == sql.ErrNoRows {
-		return false, nil
-	}
-	return false, fmt.Errorf("check artist cache freshness (settings): %w", err)
-}
-
-// GetExternalReleasesByArtistWithCache returns cached external_release rows for a given artist_id
-// that are within the specified TTL.
-func GetExternalReleasesByArtistWithCache(db *DB, artistID string, ttl time.Duration) ([]ExternalRelease, error) {
-	// A zero or negative TTL means "no cache" — always expire. Returning early
-	// here avoids the boundary pitfall where cutoff == now would treat rows
-	// cached in the current second as fresh.
-	if ttl <= 0 {
-		return nil, nil
-	}
-	// cached_at is stored in utcLayout via FormatCachedAt. Compare against an
-	// explicitly formatted cutoff string in the same layout so the
-	// lexicographic comparison is a valid time ordering.
-	cutoff := time.Now().UTC().Add(-ttl).Format(utcLayout)
-	rows, err := db.Conn().Query(
-		"SELECT rgid, artist_id, title, type, release_date, is_ignored, cached_at, secondary_types FROM external_releases WHERE artist_id = ? AND cached_at >= ?",
-		artistID, cutoff,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("query cached external releases: %w", err)
-	}
-	defer rows.Close()
-
-	var results []ExternalRelease
-	for rows.Next() {
-		var r ExternalRelease
-		var releaseType sql.NullString
-		var releaseDate sql.NullString
-		var cachedAt sql.NullTime
-		var secondaryTypes sql.NullString
-		if err := rows.Scan(&r.RGID, &r.ArtistID, &r.Title, &releaseType, &releaseDate, &r.IsIgnored, &cachedAt, &secondaryTypes); err != nil {
-			return nil, fmt.Errorf("scan cached external release: %w", err)
-		}
-		if releaseType.Valid {
-			r.Type = releaseType.String
-		}
-		if releaseDate.Valid {
-			r.ReleaseDate = releaseDate.String
-		}
-		if cachedAt.Valid {
-			r.CachedAt = cachedAt.Time
-		}
-		if secondaryTypes.Valid {
-			r.SecondaryTypes = splitSecondaryTypes(secondaryTypes.String)
-		}
-		results = append(results, r)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate cached external releases: %w", err)
-	}
-	return results, nil
-}

internal/database/external_releases_test.go

@@ -2,9 +2,7 @@ package database
 
 import (
 	"database/sql"
-	"errors"
 	"testing"
-	"time"
 )
 
 // insertTestArtist inserts a minimal artist_settings row for use in tests that need FK satisfaction.
@@ -60,8 +58,7 @@ func TestGetExternalRelease_Found(t *testing.T) {
 	}
 }
 
-// TestGetExternalRelease_NotFound verifies that a missing release returns an error
-// that wraps sql.ErrNoRows.
+// TestGetExternalRelease_NotFound verifies that a missing release returns sql.ErrNoRows.
 func TestGetExternalRelease_NotFound(t *testing.T) {
 	db, err := New(":memory:")
 	if err != nil {
@@ -70,8 +67,8 @@ func TestGetExternalRelease_NotFound(t *testing.T) {
 	defer db.Close()
 
 	_, err = GetExternalRelease(db, "nonexistent")
-	if !errors.Is(err, sql.ErrNoRows) {
-		t.Errorf("expected error wrapping sql.ErrNoRows, got %v", err)
+	if err != sql.ErrNoRows {
+		t.Errorf("expected sql.ErrNoRows, got %v", err)
 	}
 }
 
@@ -379,108 +376,3 @@ func TestSetReleaseIgnored_NotFound(t *testing.T) {
 		t.Error("expected error for nonexistent RGID, got nil")
 	}
 }
-
-// TestSecondaryTypesRoundTrip verifies that the comma-joined secondary_types
-// column round-trips through save + read with the same slice, so the cache-hit
-// type filtering (ignore_singles / ignore_compilations) sees the same data as
-// the cache-miss path.
-func TestSecondaryTypesRoundTrip(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-	if err := insertTestArtist(db, "artist-1"); err != nil {
-		t.Fatalf("insertTestArtist: %v", err)
-	}
-
-	cases := []struct {
-		name string
-		in   []string
-		want []string
-	}{
-		{"empty", nil, nil},
-		{"single", []string{"Compilation"}, []string{"Compilation"}},
-		{"multiple", []string{"Compilation", "Live", "EP"}, []string{"Compilation", "Live", "EP"}},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			r := &ExternalRelease{
-				RGID:           "rgid-" + c.name,
-				ArtistID:       "artist-1",
-				Title:          "Title " + c.name,
-				Type:           "Album",
-				SecondaryTypes: c.in,
-			}
-			if err := SaveExternalRelease(db, r); err != nil {
-				t.Fatalf("SaveExternalRelease() error: %v", err)
-			}
-			got, err := GetExternalRelease(db, r.RGID)
-			if err != nil {
-				t.Fatalf("GetExternalRelease() error: %v", err)
-			}
-			if len(got.SecondaryTypes) != len(c.want) {
-				t.Fatalf("secondary types = %v, want %v", got.SecondaryTypes, c.want)
-			}
-			for i := range c.want {
-				if got.SecondaryTypes[i] != c.want[i] {
-					t.Errorf("secondary types[%d] = %q, want %q", i, got.SecondaryTypes[i], c.want[i])
-				}
-			}
-		})
-	}
-}
-
-// TestArtistCacheFresh covers the two-signal freshness logic: a fresh
-// external_releases row, a fresh last_synced marker (empty discography), a stale
-// state, and the ttl<=0 guard.
-func TestArtistCacheFresh(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-	if err := insertTestArtist(db, "artist-1"); err != nil {
-		t.Fatalf("insertTestArtist: %v", err)
-	}
-
-	const ttl = 24 * time.Hour
-
-	// No rows at all => not fresh.
-	if fresh, err := ArtistCacheFresh(db, "artist-1", ttl); err != nil || fresh {
-		t.Fatalf("empty state: fresh=%v err=%v, want (false, nil)", fresh, err)
-	}
-
-	// ttl <= 0 => never fresh.
-	if fresh, err := ArtistCacheFresh(db, "artist-1", 0); err != nil || fresh {
-		t.Fatalf("ttl=0: fresh=%v err=%v, want (false, nil)", fresh, err)
-	}
-
-	// Fresh release row => fresh, even with an empty last_synced.
-	if _, err := db.Conn().Exec(
-		"INSERT INTO external_releases (rgid, artist_id, title, cached_at) VALUES (?, ?, ?, ?)",
-		"rgid-1", "artist-1", "Album", FormatCachedAt(time.Now().UTC()),
-	); err != nil {
-		t.Fatalf("insert release: %v", err)
-	}
-	if fresh, err := ArtistCacheFresh(db, "artist-1", ttl); err != nil || !fresh {
-		t.Fatalf("fresh release: fresh=%v err=%v, want (true, nil)", fresh, err)
-	}
-
-	// Remove the release row, set a fresh last_synced (empty discography still cached).
-	if _, err := db.Conn().Exec("DELETE FROM external_releases WHERE artist_id = ?", "artist-1"); err != nil {
-		t.Fatalf("delete releases: %v", err)
-	}
-	if _, err := db.Conn().Exec("UPDATE artist_settings SET last_synced = ? WHERE id = ?", FormatCachedAt(time.Now().UTC()), "artist-1"); err != nil {
-		t.Fatalf("touch synced: %v", err)
-	}
-	if fresh, err := ArtistCacheFresh(db, "artist-1", ttl); err != nil || !fresh {
-		t.Fatalf("fresh last_synced: fresh=%v err=%v, want (true, nil)", fresh, err)
-	}
-
-	// Stale both signals => not fresh.
-	db.Conn().Exec("UPDATE artist_settings SET last_synced = ? WHERE id = ?", FormatCachedAt(time.Now().UTC().Add(-2*ttl)), "artist-1")
-	if fresh, err := ArtistCacheFresh(db, "artist-1", ttl); err != nil || fresh {
-		t.Fatalf("stale both: fresh=%v err=%v, want (false, nil)", fresh, err)
-	}
-}

internal/database/local_albums.go

@@ -1,103 +0,0 @@
-package database
-
-import (
-	"database/sql"
-	"fmt"
-)
-
-// SaveLocalAlbum inserts or replaces a local_albums row.
-func SaveLocalAlbum(db *DB, album *LocalAlbum) error {
-	_, err := db.Conn().Exec(
-		"INSERT OR REPLACE INTO local_albums (id, artist_id, title) VALUES (?, ?, ?)",
-		album.ID, album.ArtistID, album.Title,
-	)
-	if err != nil {
-		return fmt.Errorf("save local album: %w", err)
-	}
-	return nil
-}
-
-// SaveLocalAlbumTx inserts or replaces a local_albums row within an existing transaction.
-func SaveLocalAlbumTx(tx *sql.Tx, album *LocalAlbum) error {
-	_, err := tx.Exec(
-		"INSERT OR REPLACE INTO local_albums (id, artist_id, title) VALUES (?, ?, ?)",
-		album.ID, album.ArtistID, album.Title,
-	)
-	if err != nil {
-		return fmt.Errorf("save local album: %w", err)
-	}
-	return nil
-}
-
-// DeleteLocalAlbumsByArtistTx removes all local_albums rows for a given artist within an existing transaction.
-func DeleteLocalAlbumsByArtistTx(tx *sql.Tx, artistID string) error {
-	_, err := tx.Exec(
-		"DELETE FROM local_albums WHERE artist_id = ?",
-		artistID,
-	)
-	if err != nil {
-		return fmt.Errorf("delete local albums for artist %s: %w", artistID, err)
-	}
-	return nil
-}
-
-// DeleteLocalAlbumsByArtist removes all local_albums rows for a given artist.
-func DeleteLocalAlbumsByArtist(db *DB, artistID string) error {
-	_, err := db.Conn().Exec(
-		"DELETE FROM local_albums WHERE artist_id = ?",
-		artistID,
-	)
-	if err != nil {
-		return fmt.Errorf("delete local albums for artist %s: %w", artistID, err)
-	}
-	return nil
-}
-
-// GetLocalAlbumsByArtist returns all local_albums for a given artist.
-func GetLocalAlbumsByArtist(db *DB, artistID string) ([]LocalAlbum, error) {
-	rows, err := db.Conn().Query(
-		"SELECT id, artist_id, title FROM local_albums WHERE artist_id = ?",
-		artistID,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("query local albums for artist %s: %w", artistID, err)
-	}
-	defer rows.Close()
-
-	var results []LocalAlbum
-	for rows.Next() {
-		var a LocalAlbum
-		if err := rows.Scan(&a.ID, &a.ArtistID, &a.Title); err != nil {
-			return nil, fmt.Errorf("scan local album: %w", err)
-		}
-		results = append(results, a)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate local albums: %w", err)
-	}
-	return results, nil
-}
-
-// GetAllLocalAlbums returns all rows from local_albums.
-func GetAllLocalAlbums(db *DB) ([]LocalAlbum, error) {
-	rows, err := db.Conn().Query(
-		"SELECT id, artist_id, title FROM local_albums",
-	)
-	if err != nil {
-		return nil, fmt.Errorf("query all local albums: %w", err)
-	}
-	defer rows.Close()
-
-	var results []LocalAlbum
-	for rows.Next() {
-		var a LocalAlbum
-		if err := rows.Scan(&a.ID, &a.ArtistID, &a.Title); err != nil {
-			return nil, fmt.Errorf("scan local album: %w", err)
-		}
-		results = append(results, a)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate local albums: %w", err)
-	}
-	return results, nil
-}

internal/database/notifications.go

@@ -1,37 +1,16 @@
 package database
 
 import (
-	"errors"
 	"fmt"
-
-	sqlite3 "github.com/mattn/go-sqlite3"
 )
 
 // MarkNotificationSent records that a notification has been sent for the given RGID.
-//
-// Uses INSERT OR IGNORE so a pre-existing marker for the same RGID (a
-// same-second re-notify colliding on the (rgid, sent_at) primary key) is a
-// no-op rather than an error: the marker's presence, not its exact timestamp,
-// is what matters for idempotency.
-//
-// A concurrent re-sync that prunes the external_releases row before this insert
-// would violate the FK constraint. OR IGNORE does NOT downgrade FK violations
-// in this SQLite build, so the FK error is caught explicitly and treated as a
-// benign no-op ("the release is already gone"). This ensures a single vanished
-// release cannot abort a whole digest's mark-sent loop and trigger duplicate
-// notifications on the next run.
 func MarkNotificationSent(db *DB, rgid string) error {
 	_, err := db.Conn().Exec(
-		"INSERT OR IGNORE INTO notifications_sent (rgid) VALUES (?)",
+		"INSERT INTO notifications_sent (rgid) VALUES (?)",
 		rgid,
 	)
 	if err != nil {
-		var sqliteErr sqlite3.Error
-		if errors.As(err, &sqliteErr) && sqliteErr.Code == sqlite3.ErrConstraint &&
-			sqliteErr.ExtendedCode == sqlite3.ErrConstraintForeignKey {
-			// Release row was pruned concurrently; nothing to mark.
-			return nil
-		}
 		return fmt.Errorf("mark notification sent: %w", err)
 	}
 	return nil
@@ -49,16 +28,13 @@ func IsNotificationSent(db *DB, rgid string) (bool, error) {
 	return count > 0, nil
 }
 
-// GetUnnotifiedReleases returns all external_release rows for monitored artists
-// that have no entry in notifications_sent. Releases belonging to unmonitored
-// artists are excluded so the digest honors the monitoring contract.
+// GetUnnotifiedReleases returns all external_release rows that have no entry in notifications_sent.
 func GetUnnotifiedReleases(db *DB) ([]ExternalRelease, error) {
 	rows, err := db.Conn().Query(`
-		SELECT e.rgid, e.artist_id, e.title, COALESCE(e.type,''), COALESCE(e.release_date,''), e.is_ignored
+		SELECT e.rgid, e.artist_id, e.title, e.type, e.release_date, e.is_ignored
 		FROM external_releases e
-		JOIN artist_settings s ON e.artist_id = s.id
 		LEFT JOIN notifications_sent n ON e.rgid = n.rgid
-		WHERE s.monitored = 1 AND n.rgid IS NULL AND e.is_ignored = 0
+		WHERE n.rgid IS NULL AND e.is_ignored = 0
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("query unnotified releases: %w", err)

internal/database/notifications_test.go

@@ -41,38 +41,9 @@ func TestMarkNotificationSent_New(t *testing.T) {
 	}
 }
 
-// TestMarkNotificationSent_MissingReleaseIsNoOp verifies that marking a release
-// whose external_releases row does not exist (e.g. pruned by a concurrent
-// re-sync) does not error: the FK violation is swallowed by INSERT OR IGNORE so
-// a single vanished release cannot abort a digest's mark-sent loop.
-func TestMarkNotificationSent_MissingReleaseIsNoOp(t *testing.T) {
-	db, err := New(":memory:")
-	if err != nil {
-		t.Fatalf("New() error: %v", err)
-	}
-	defer db.Close()
-
-	// No artist/release inserted: rgid-gone has no external_releases row.
-	if err := MarkNotificationSent(db, "rgid-gone"); err != nil {
-		t.Fatalf("MarkNotificationSent() for missing release should be a no-op, got error: %v", err)
-	}
-
-	// Nothing should have been recorded (FK violation ignored, row skipped).
-	var count int
-	if err := db.Conn().QueryRow("SELECT COUNT(*) FROM notifications_sent WHERE rgid = ?", "rgid-gone").Scan(&count); err != nil {
-		t.Fatalf("count query error: %v", err)
-	}
-	if count != 0 {
-		t.Errorf("expected 0 notification rows for missing release, got %d", count)
-	}
-}
-
-// TestMarkNotificationSent_DuplicateSecond verifies that marking the same RGID
-// twice within the same second is an idempotent no-op (INSERT OR IGNORE) rather
-// than an error: a same-second collision on the composite primary key
-// (rgid, sent_at) must not abort a digest's mark-sent loop, since that would
-// leave later releases unmarked and cause duplicate notifications on the next
-// run. The marker's presence, not its exact timestamp, is what matters.
+// TestMarkNotificationSent_DuplicateSecond verifies that inserting the same RGID twice
+// within the same second fails due to the composite primary key (rgid, sent_at).
+// In practice, notifications are sent at most once per day, so this is acceptable.
 func TestMarkNotificationSent_DuplicateSecond(t *testing.T) {
 	db, err := New(":memory:")
 	if err != nil {
@@ -89,9 +60,10 @@ func TestMarkNotificationSent_DuplicateSecond(t *testing.T) {
 	if err := MarkNotificationSent(db, "rgid-1"); err != nil {
 		t.Fatalf("first MarkNotificationSent() error: %v", err)
 	}
-	// Second mark in the same second should be a silent no-op, not an error.
-	if err := MarkNotificationSent(db, "rgid-1"); err != nil {
-		t.Fatalf("duplicate MarkNotificationSent() should be a no-op, got error: %v", err)
+	// Second insert in the same second should fail with a UNIQUE constraint error.
+	err = MarkNotificationSent(db, "rgid-1")
+	if err == nil {
+		t.Fatal("expected UNIQUE constraint error on duplicate insert, got nil")
 	}
 
 	// Should still have exactly one row.

internal/musicbrainz/api.go

@@ -1,124 +0,0 @@
-package musicbrainz
-
-import (
-	"context"
-	"fmt"
-	"net/url"
-
-	"naviwatcher/internal/database"
-)
-
-// includedTypes contains release-group primary types that should be included
-// when no more specific type classification applies.
-var includedTypes = map[string]bool{
-	"Album":  true,
-	"Single": true,
-	"EP":     true,
-}
-
-// GetArtistReleaseGroups fetches all release groups for a given artist from MusicBrainz.
-// It queries the artist's release groups via the MusicBrainz Web Service API,
-// parses the XML response, and applies status and type filtering.
-//
-// The method handles pagination automatically by following offset parameters
-// until all release groups are fetched.
-func (c *MusicBrainzClient) GetArtistReleaseGroups(ctx context.Context, artistMBID string) ([]ReleaseGroup, error) {
-	var allGroups []ReleaseGroup
-	offset := 0
-	limit := 100 // MusicBrainz max limit per request
-
-	for {
-		params := url.Values{}
-		params.Set("artist", artistMBID)
-		params.Set("limit", fmt.Sprintf("%d", limit))
-		params.Set("offset", fmt.Sprintf("%d", offset))
-		path := "/release-group?" + params.Encode()
-
-		body, err := c.doGet(ctx, path)
-		if err != nil {
-			return nil, fmt.Errorf("fetch release groups for artist %s: %w", artistMBID, err)
-		}
-
-		parsed, err := ParseReleaseGroups(body)
-		if err != nil {
-			return nil, fmt.Errorf("parse release groups for artist %s: %w", artistMBID, err)
-		}
-
-		allGroups = append(allGroups, parsed.ReleaseGroups...)
-
-		// Stop when a page is empty (no more results) or when the page
-		// returned fewer items than the request limit — a reliable end-of-data
-		// signal. We intentionally do NOT trust parsed.Count for the cutoff:
-		// MusicBrainz occasionally reports an inaccurate count, which would
-		// prematurely truncate an artist's discography and hide missing
-		// releases. The empty-page check also prevents an infinite loop if the
-		// API keeps returning a non-empty page past the reported count.
-		if len(parsed.ReleaseGroups) == 0 || len(parsed.ReleaseGroups) < limit {
-			break
-		}
-
-		// Check context cancellation between pages for responsive shutdown.
-		if err := ctx.Err(); err != nil {
-			return nil, fmt.Errorf("fetch release groups for artist %s: %w", artistMBID, err)
-		}
-
-		offset += limit
-	}
-
-	return allGroups, nil
-}
-
-// GetArtistReleaseGroups fetches all release groups for a given artist from MusicBrainz.
-// It queries the artist's release groups via the MusicBrainz Web Service API,
-// parses the XML response, and applies status and type filtering.
-//
-// The method handles pagination automatically by following offset parameters
-// until all release groups are fetched.
-
-// ToExternalRelease converts a ReleaseGroup to an ExternalRelease for database
-// persistence. artistID is the canonical artist key from artist_settings (the
-// Navidrome artist ID), which is what external_releases.artist_id references and
-// what the scanner joins on. The MusicBrainz release-group's own ArtistID (an
-// MBID) must NOT be stored here, because artist_settings is keyed by the
-// Navidrome ID and the foreign key / join would otherwise never match.
-func (rg *ReleaseGroup) ToExternalRelease(artistID string) *database.ExternalRelease {
-	// The primary type and the secondary types are both persisted so that the
-	// cache-hit path in SyncArtistDiscography can re-apply the same
-	// IgnoreSingles / IgnoreCompilations rules (which consider secondary types)
-	// as the cache-miss path, keeping results stable across cache refreshes.
-	return &database.ExternalRelease{
-		RGID:           rg.ID,
-		ArtistID:       artistID,
-		Title:          rg.Title,
-		ReleaseDate:    rg.ReleaseDate,
-		Type:           rg.Type,
-		SecondaryTypes: rg.SecondaryTypes,
-	}
-}
-
-// FilterReleaseGroups applies type filtering to a list of release groups.
-// It includes only Album/Single/EP primary types, or release groups whose
-// secondary type list contains Single/EP/Compilation (e.g. an "Album" that is
-// also a "Compilation"). The IgnoreSingles / IgnoreCompilations toggles drop
-// release groups classified as such via either primary or secondary type.
-//
-// Release groups carry no status in ws/2, so there is no status filtering.
-func FilterReleaseGroups(groups []ReleaseGroup, opts FilterOptions) []ReleaseGroup {
-	// First filter by base allowed types (Album/Single/EP) or those with Single/EP/Compilation as secondary type
-	var preFiltered []ReleaseGroup
-	for _, rg := range groups {
-		if !isTypeIncluded(rg.Type) && !hasSliceType(rg.SecondaryTypes, "Single", "EP", "Compilation") {
-			continue
-		}
-		preFiltered = append(preFiltered, rg)
-	}
-
-	// Then apply the IgnoreSingles/IgnoreCompilations toggles using the centralized logic
-	return ApplyTypeTogglesToReleaseGroups(preFiltered, opts)
-}
-
-// isTypeIncluded returns true if the given primary type is in the base
-// included set (Album/Single/EP).
-func isTypeIncluded(releaseType string) bool {
-	return includedTypes[releaseType]
-}

internal/musicbrainz/api_test.go

@@ -1,361 +0,0 @@
-package musicbrainz
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"golang.org/x/time/rate"
-	"naviwatcher/internal/config"
-)
-
-// ---------- FilterReleaseGroups tests ----------
-
-// Release groups carry no status in ws/2, so status values are irrelevant to
-// filtering. These groups differ only by the (ignored) status attribute; all
-// are Album/Single and should be retained.
-func TestFilterReleaseGroups_StatusIsNotFiltered(t *testing.T) {
-	groups := []ReleaseGroup{
-		{ID: "rg-1", Title: "Official Album", Type: "Album"},
-		{ID: "rg-2", Title: "Bootleg Live", Type: "Album"},
-		{ID: "rg-3", Title: "Promo CD", Type: "Single"},
-		{ID: "rg-4", Title: "Pseudo Release", Type: "Album"},
-	}
-
-	result := FilterReleaseGroups(groups, FilterOptions{})
-
-	if len(result) != 4 {
-		t.Fatalf("FilterReleaseGroups() returned %d groups, want 4", len(result))
-	}
-}
-
-func TestFilterReleaseGroups_IncludesOnlyAllowedTypes(t *testing.T) {
-	groups := []ReleaseGroup{
-		{ID: "rg-1", Title: "Album", Type: "Album"},
-		{ID: "rg-2", Title: "Single", Type: "Single"},
-		{ID: "rg-3", Title: "EP", Type: "EP"},
-		// A compilation whose primary type is Album (the common case) is
-		// classified via its secondary type and must be included.
-		{ID: "rg-4", Title: "Greatest Hits", Type: "Album", SecondaryTypes: []string{"Compilation"}},
-		{ID: "rg-5", Title: "Soundtrack", Type: "Soundtrack"},
-		{ID: "rg-6", Title: "Live", Type: "Live"},
-		{ID: "rg-7", Title: "Remix", Type: "Remix"},
-	}
-
-	result := FilterReleaseGroups(groups, FilterOptions{})
-
-	if len(result) != 4 {
-		t.Fatalf("FilterReleaseGroups() returned %d groups, want 4", len(result))
-	}
-
-	allowedIDs := map[string]bool{"rg-1": true, "rg-2": true, "rg-3": true, "rg-4": true}
-	for _, rg := range result {
-		if !allowedIDs[rg.ID] {
-			t.Errorf("unexpected group %q in filtered results", rg.ID)
-		}
-	}
-}
-
-func TestFilterReleaseGroups_IgnoreSingles(t *testing.T) {
-	groups := []ReleaseGroup{
-		{ID: "rg-1", Title: "Album", Type: "Album"},
-		{ID: "rg-2", Title: "Single", Type: "Single"},
-		{ID: "rg-3", Title: "EP", Type: "EP"},
-		// Single expressed via secondary type (primary is Album).
-		{ID: "rg-4", Title: "Single from Album", Type: "Album", SecondaryTypes: []string{"Single"}},
-	}
-
-	result := FilterReleaseGroups(groups, FilterOptions{IgnoreSingles: true})
-
-	if len(result) != 1 {
-		t.Fatalf("FilterReleaseGroups() returned %d groups, want 1", len(result))
-	}
-	for _, rg := range result {
-		if rg.Type == "Single" || rg.Type == "EP" || contains(rg.SecondaryTypes, "Single") || contains(rg.SecondaryTypes, "EP") {
-			t.Errorf("single/ep %q should have been filtered out", rg.ID)
-		}
-	}
-}
-
-func TestFilterReleaseGroups_IgnoreCompilations(t *testing.T) {
-	groups := []ReleaseGroup{
-		{ID: "rg-1", Title: "Album", Type: "Album"},
-		{ID: "rg-2", Title: "Greatest Hits", Type: "Album", SecondaryTypes: []string{"Compilation"}},
-		{ID: "rg-3", Title: "EP", Type: "EP"},
-	}
-
-	result := FilterReleaseGroups(groups, FilterOptions{IgnoreCompilations: true})
-
-	if len(result) != 2 {
-		t.Fatalf("FilterReleaseGroups() returned %d groups, want 2", len(result))
-	}
-	for _, rg := range result {
-		if rg.Type == "Compilation" || contains(rg.SecondaryTypes, "Compilation") {
-			t.Errorf("compilation %q should have been filtered out", rg.ID)
-		}
-	}
-}
-
-// ---------- ReleaseGroup.ToExternalRelease tests ----------
-
-func TestReleaseGroup_ToExternalRelease(t *testing.T) {
-	rg := ReleaseGroup{
-		ID:          "rg-uuid-1",
-		Title:       "Dark Side of the Moon",
-		Type:        "Album",
-		ArtistID:    "mbid-artist-uuid-1",
-		ArtistName:  "Pink Floyd",
-		ReleaseDate: "1973-03-01",
-	}
-
-	// ToExternalRelease stores the canonical artist key (Navidrome ID), not the
-	// MusicBrainz ArtistID, so external_releases.artist_id matches artist_settings.
-	const navidromeArtistID = "navidrome-artist-uuid-1"
-	er := rg.ToExternalRelease(navidromeArtistID)
-
-	if er.RGID != "rg-uuid-1" {
-		t.Errorf("RGID = %q, want %q", er.RGID, "rg-uuid-1")
-	}
-	if er.ArtistID != navidromeArtistID {
-		t.Errorf("ArtistID = %q, want %q", er.ArtistID, navidromeArtistID)
-	}
-	if er.Title != "Dark Side of the Moon" {
-		t.Errorf("Title = %q, want %q", er.Title, "Dark Side of the Moon")
-	}
-	if er.Type != "Album" {
-		t.Errorf("Type = %q, want %q", er.Type, "Album")
-	}
-	if er.ReleaseDate != "1973-03-01" {
-		t.Errorf("ReleaseDate = %q, want %q", er.ReleaseDate, "1973-03-01")
-	}
-}
-
-// ---------- GetArtistReleaseGroups tests ----------
-
-func TestGetArtistReleaseGroups_Success(t *testing.T) {
-	artistMBID := "artist-uuid-test"
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-<metadata xmlns="http://musicbrainz.org/ns/mmd-2.0#">
-  <release-group-list count="2">
-    <release-group id="rg-uuid-1" type="Album">
-      <title>Dark Side of the Moon</title>
-      <first-release-date>1973-03-01</first-release-date>
-      <artist-credit>
-        <name-credit>
-          <artist id="` + artistMBID + `">
-            <name>Pink Floyd</name>
-          </artist>
-        </name-credit>
-      </artist-credit>
-    </release-group>
-    <release-group id="rg-uuid-2" type="Single">
-      <title>Another Brick in the Wall</title>
-      <first-release-date>1979-11-30</first-release-date>
-      <artist-credit>
-        <name-credit>
-          <artist id="` + artistMBID + `">
-            <name>Pink Floyd</name>
-          </artist>
-        </name-credit>
-      </artist-credit>
-    </release-group>
-  </release-group-list>
-</metadata>`))
-	}))
-	defer server.Close()
-
-	cfg := config.MusicBrainzConfig{
-		UserAgent: "naviwatcher/0.1.0 (test@example.com)",
-	}
-
-	rl := rate.NewLimiter(rate.Limit(1000), 1000)
-	client := &MusicBrainzClient{
-		httpClient:  server.Client(),
-		userAgent:   cfg.UserAgent,
-		baseURL:     server.URL,
-		rateLimiter: rl,
-	}
-
-	groups, err := client.GetArtistReleaseGroups(context.Background(), artistMBID)
-	if err != nil {
-		t.Fatalf("GetArtistReleaseGroups() error = %v", err)
-	}
-
-	if len(groups) != 2 {
-		t.Fatalf("GetArtistReleaseGroups() returned %d groups, want 2", len(groups))
-	}
-
-	if groups[0].Title != "Dark Side of the Moon" {
-		t.Errorf("groups[0].Title = %q, want %q", groups[0].Title, "Dark Side of the Moon")
-	}
-	if groups[1].Title != "Another Brick in the Wall" {
-		t.Errorf("groups[1].Title = %q, want %q", groups[1].Title, "Another Brick in the Wall")
-	}
-}
-
-func TestGetArtistReleaseGroups_Pagination(t *testing.T) {
-	artistMBID := "artist-page-test"
-	requestCount := 0
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		requestCount++
-		offset := r.URL.Query().Get("offset")
-
-		w.Header().Set("Content-Type", "application/xml")
-
-		if offset == "0" || offset == "" {
-			// First page: return 100 results (full page, matching limit) to trigger pagination
-			xml := `<?xml version="1.0" encoding="UTF-8"?>
-<metadata xmlns="http://musicbrainz.org/ns/mmd-2.0#">
-  <release-group-list count="101">`
-			for i := 0; i < 100; i++ {
-				xml += `
-    <release-group id="rg-page1-` + string(rune('0'+i%10)) + `" type="Album">
-      <title>Page 1 Album</title>
-      <first-release-date>2020-01-01</first-release-date>
-      <artist-credit>
-        <name-credit>
-          <artist id="` + artistMBID + `"><name>Artist</name></artist>
-        </name-credit>
-      </artist-credit>
-    </release-group>`
-			}
-			xml += `
-  </release-group-list>
-</metadata>`
-			w.Write([]byte(xml))
-		} else {
-			// Second page: return only 1 result (< limit, signaling last page)
-			w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-<metadata xmlns="http://musicbrainz.org/ns/mmd-2.0#">
-  <release-group-list count="101">
-    <release-group id="rg-page2" type="Album">
-      <title>Page 2 Album</title>
-      <first-release-date>2021-01-01</first-release-date>
-      <artist-credit>
-        <name-credit>
-          <artist id="` + artistMBID + `"><name>Artist</name></artist>
-        </name-credit>
-      </artist-credit>
-    </release-group>
-  </release-group-list>
-</metadata>`))
-		}
-	}))
-	defer server.Close()
-
-	cfg := config.MusicBrainzConfig{
-		UserAgent: "naviwatcher/0.1.0 (test@example.com)",
-	}
-
-	rl := rate.NewLimiter(rate.Limit(1000), 1000)
-	client := &MusicBrainzClient{
-		httpClient:  server.Client(),
-		userAgent:   cfg.UserAgent,
-		baseURL:     server.URL,
-		rateLimiter: rl,
-	}
-
-	groups, err := client.GetArtistReleaseGroups(context.Background(), artistMBID)
-	if err != nil {
-		t.Fatalf("GetArtistReleaseGroups() error = %v", err)
-	}
-
-	// Should have fetched 2 pages: 100 from first + 1 from second = 101 total
-	if len(groups) != 101 {
-		t.Fatalf("GetArtistReleaseGroups() returned %d groups, want 101", len(groups))
-	}
-
-	if requestCount != 2 {
-		t.Errorf("expected 2 paginated requests, got %d", requestCount)
-	}
-}
-
-func TestGetArtistReleaseGroups_EmptyResult(t *testing.T) {
-	artistMBID := "artist-empty"
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-<metadata xmlns="http://musicbrainz.org/ns/mmd-2.0#">
-  <release-group-list count="0">
-  </release-group-list>
-</metadata>`))
-	}))
-	defer server.Close()
-
-	cfg := config.MusicBrainzConfig{
-		UserAgent: "naviwatcher/0.1.0 (test@example.com)",
-	}
-
-	rl := rate.NewLimiter(rate.Limit(1000), 1000)
-	client := &MusicBrainzClient{
-		httpClient:  server.Client(),
-		userAgent:   cfg.UserAgent,
-		baseURL:     server.URL,
-		rateLimiter: rl,
-	}
-
-	groups, err := client.GetArtistReleaseGroups(context.Background(), artistMBID)
-	if err != nil {
-		t.Fatalf("GetArtistReleaseGroups() error = %v", err)
-	}
-
-	if len(groups) != 0 {
-		t.Errorf("GetArtistReleaseGroups() returned %d groups, want 0", len(groups))
-	}
-}
-
-func TestGetArtistReleaseGroups_ServerError(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusServiceUnavailable)
-		w.Write([]byte("Rate limit exceeded"))
-	}))
-	defer server.Close()
-
-	cfg := config.MusicBrainzConfig{
-		UserAgent: "naviwatcher/0.1.0 (test@example.com)",
-	}
-
-	rl := rate.NewLimiter(rate.Limit(1000), 1000)
-	client := &MusicBrainzClient{
-		httpClient:  server.Client(),
-		userAgent:   cfg.UserAgent,
-		baseURL:     server.URL,
-		rateLimiter: rl,
-	}
-
-	_, err := client.GetArtistReleaseGroups(context.Background(), "artist-1")
-	if err == nil {
-		t.Fatal("GetArtistReleaseGroups() expected error for server error, got nil")
-	}
-}
-
-func TestGetArtistReleaseGroups_InvalidXML(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		w.Write([]byte(`this is not valid xml`))
-	}))
-	defer server.Close()
-
-	cfg := config.MusicBrainzConfig{
-		UserAgent: "naviwatcher/0.1.0 (test@example.com)",
-	}
-
-	rl := rate.NewLimiter(rate.Limit(1000), 1000)
-	client := &MusicBrainzClient{
-		httpClient:  server.Client(),
-		userAgent:   cfg.UserAgent,
-		baseURL:     server.URL,
-		rateLimiter: rl,
-	}
-
-	_, err := client.GetArtistReleaseGroups(context.Background(), "artist-1")
-	if err == nil {
-		t.Fatal("GetArtistReleaseGroups() expected error for invalid XML, got nil")
-	}
-}

internal/musicbrainz/client.go

@@ -1,166 +0,0 @@
-package musicbrainz
-
-import (
-	"context"
-	"encoding/xml"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"time"
-
-	"golang.org/x/time/rate"
-	"naviwatcher/internal/config"
-)
-
-// MusicBrainzClient wraps net/http.Client with rate limiting and configuration
-// for the MusicBrainz Web Service API (version 2).
-type MusicBrainzClient struct {
-	httpClient  *http.Client
-	userAgent   string
-	baseURL     string
-	rateLimiter *rate.Limiter
-}
-
-// NewClient creates a new MusicBrainzClient from the given configuration.
-// It initializes the HTTP client with a 30-second timeout and sets up
-// a rate limiter for 1 request per second as required by MusicBrainz policy.
-func NewClient(cfg config.MusicBrainzConfig) *MusicBrainzClient {
-	return &MusicBrainzClient{
-		httpClient: &http.Client{
-			Timeout: 30 * time.Second,
-		},
-		userAgent:   cfg.UserAgent,
-		baseURL:     "https://musicbrainz.org/ws/2",
-		rateLimiter: rate.NewLimiter(rate.Limit(1), 1),
-	}
-}
-
-// Close releases resources held by the client, draining any idle keep-alive
-// connections so they don't linger until garbage collection.
-func (c *MusicBrainzClient) Close() {
-	c.httpClient.CloseIdleConnections()
-}
-
-// doGet performs a rate-limited HTTP GET request to the MusicBrainz API.
-// It blocks until the rate limiter allows the request, then sets the proper
-// User-Agent header and returns the response body.
-func (c *MusicBrainzClient) doGet(ctx context.Context, path string) ([]byte, error) {
-	if err := c.rateLimiter.Wait(ctx); err != nil {
-		return nil, fmt.Errorf("rate limiter wait: %w", err)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+path, nil)
-	if err != nil {
-		return nil, fmt.Errorf("create request: %w", err)
-	}
-	req.Header.Set("User-Agent", c.userAgent)
-	req.Header.Set("Accept", "application/xml")
-
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("execute request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
-		return nil, fmt.Errorf("musicbrainz API returned HTTP %d: %s", resp.StatusCode, string(body))
-	}
-
-	body, err := io.ReadAll(io.LimitReader(resp.Body, 10*1024*1024)) // 10MB limit
-	if err != nil {
-		return nil, fmt.Errorf("read response body: %w", err)
-	}
-
-	return body, nil
-}
-
-// mbArtistRef represents the nested artist element inside a release-group.
-type mbArtistRef struct {
-	ID   string `xml:"id,attr"`
-	Name string `xml:"name"`
-}
-
-// mbNameCredit represents the name-credit element inside a release-group.
-type mbNameCredit struct {
-	Artist mbArtistRef `xml:"artist"`
-}
-
-// mbArtistCredit represents the artist-credit element inside a release-group.
-type mbArtistCredit struct {
-	NameCredit mbNameCredit `xml:"name-credit"`
-}
-
-// mbReleaseGroup represents the XML structure of a single release-group
-// in the MusicBrainz release-group list response.
-//
-// Note: release groups do NOT carry a "status" attribute in ws/2 (status
-// belongs to individual releases, not release groups), so it is intentionally
-// absent here. Type classification is read from the authoritative
-// <primary-type> / <secondary-type-list> elements rather than the legacy
-// "type" attribute, which only reflects the primary type and cannot detect
-// e.g. a compilation whose primary type is Album.
-type mbReleaseGroup struct {
-	ID           string           `xml:"id,attr"`
-	Title        string           `xml:"title"`
-	TypeAttr     string           `xml:"type,attr"`
-	PrimaryType  string           `xml:"primary-type"`
-	Secondary    mbSecondaryTypes `xml:"secondary-type-list"`
-	ArtistCredit mbArtistCredit   `xml:"artist-credit"`
-	ReleaseDate  string           `xml:"first-release-date"`
-}
-
-// mbSecondaryTypes captures the <secondary-type-list> element, which holds
-// zero or more <secondary-type> children (e.g. Live, Compilation, Remix).
-type mbSecondaryTypes struct {
-	Types []string `xml:"secondary-type"`
-}
-
-// mbReleaseGroupListXML wraps the release-group-list element to properly
-// capture both child elements and the count attribute.
-type mbReleaseGroupListXML struct {
-	ReleaseGroups []mbReleaseGroup `xml:"release-group"`
-	Count         int              `xml:"count,attr"`
-}
-
-// mbReleaseGroupList represents the XML structure of a release-group list response.
-type mbReleaseGroupList struct {
-	XMLName          xml.Name              `xml:"metadata"`
-	ReleaseGroupList mbReleaseGroupListXML `xml:"release-group-list"`
-}
-
-// ParseReleaseGroups parses a MusicBrainz release-group list XML response
-// into a ParsedReleaseGroups struct.
-func ParseReleaseGroups(data []byte) (*ParsedReleaseGroups, error) {
-	var list mbReleaseGroupList
-	if err := xml.Unmarshal(data, &list); err != nil {
-		return nil, fmt.Errorf("parse release-group XML: %w", err)
-	}
-
-	result := &ParsedReleaseGroups{
-		Count: list.ReleaseGroupList.Count,
-	}
-	for _, rg := range list.ReleaseGroupList.ReleaseGroups {
-		// Prefer the authoritative <primary-type> element; fall back to the
-		// legacy "type" attribute (which reflects the primary type) when the
-		// element is absent. The attribute is space-separated primary+secondary,
-		// so take the first token as the primary type.
-		primary := rg.PrimaryType
-		if primary == "" && rg.TypeAttr != "" {
-			if fields := strings.Fields(rg.TypeAttr); len(fields) > 0 {
-				primary = fields[0]
-			}
-		}
-		result.ReleaseGroups = append(result.ReleaseGroups, ReleaseGroup{
-			ID:             rg.ID,
-			Title:          rg.Title,
-			Type:           primary,
-			SecondaryTypes: rg.Secondary.Types,
-			ArtistID:       rg.ArtistCredit.NameCredit.Artist.ID,
-			ArtistName:     rg.ArtistCredit.NameCredit.Artist.Name,
-			ReleaseDate:    rg.ReleaseDate,
-		})
-	}
-	return result, nil
-}

internal/musicbrainz/client_test.go

@@ -1,203 +0,0 @@
-package musicbrainz
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"sync"
-	"testing"
-	"time"
-
-	"golang.org/x/time/rate"
-	"naviwatcher/internal/config"
-)
-
-func TestNewClient_ValidConfig(t *testing.T) {
-	cfg := config.MusicBrainzConfig{
-		UserAgent: "naviwatcher/0.1.0 (test@example.com)",
-	}
-
-	client := NewClient(cfg)
-
-	if client == nil {
-		t.Fatal("NewClient() returned nil client")
-	}
-
-	if client.httpClient == nil {
-		t.Fatal("NewClient() returned client with nil http.Client")
-	}
-
-	if client.userAgent != cfg.UserAgent {
-		t.Errorf("NewClient().userAgent = %q, want %q", client.userAgent, cfg.UserAgent)
-	}
-
-	expectedBaseURL := "https://musicbrainz.org/ws/2"
-	if client.baseURL != expectedBaseURL {
-		t.Errorf("NewClient().baseURL = %q, want %q", client.baseURL, expectedBaseURL)
-	}
-
-	if client.rateLimiter == nil {
-		t.Fatal("NewClient() returned client with nil rate limiter")
-	}
-}
-
-func TestDoGet_Success(t *testing.T) {
-	var mu sync.Mutex
-	var gotUserAgent, gotAccept string
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		mu.Lock()
-		gotUserAgent = r.Header.Get("User-Agent")
-		gotAccept = r.Header.Get("Accept")
-		mu.Unlock()
-		w.Header().Set("Content-Type", "application/xml")
-		w.Write([]byte(`<metadata><test>ok</test></metadata>`))
-	}))
-	defer server.Close()
-
-	cfg := config.MusicBrainzConfig{
-		UserAgent: "naviwatcher/0.1.0 (test@example.com)",
-	}
-
-	rl := rate.NewLimiter(rate.Limit(1000), 1000) // high rate to avoid blocking in tests
-	client := &MusicBrainzClient{
-		httpClient:  server.Client(),
-		userAgent:   cfg.UserAgent,
-		baseURL:     server.URL,
-		rateLimiter: rl,
-	}
-
-	body, err := client.doGet(context.Background(), "/test")
-	if err != nil {
-		t.Fatalf("doGet() error = %v", err)
-	}
-
-	if string(body) != `<metadata><test>ok</test></metadata>` {
-		t.Errorf("doGet() body = %q", string(body))
-	}
-
-	mu.Lock()
-	if gotUserAgent == "" {
-		t.Error("doGet() request missing User-Agent header")
-	}
-	if gotAccept != "application/xml" {
-		t.Errorf("doGet() Accept header = %q, want %q", gotAccept, "application/xml")
-	}
-	mu.Unlock()
-}
-
-func TestDoGet_Non200Status(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusServiceUnavailable)
-		w.Write([]byte("Rate limit exceeded"))
-	}))
-	defer server.Close()
-
-	cfg := config.MusicBrainzConfig{
-		UserAgent: "naviwatcher/0.1.0 (test@example.com)",
-	}
-
-	rl := rate.NewLimiter(rate.Limit(1000), 1000)
-	client := &MusicBrainzClient{
-		httpClient:  server.Client(),
-		userAgent:   cfg.UserAgent,
-		baseURL:     server.URL,
-		rateLimiter: rl,
-	}
-
-	_, err := client.doGet(context.Background(), "/test")
-	if err == nil {
-		t.Fatal("doGet() expected error for non-200 status, got nil")
-	}
-}
-
-func TestDoGet_ServerUnreachable(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
-	server.Close()
-
-	cfg := config.MusicBrainzConfig{
-		UserAgent: "naviwatcher/0.1.0 (test@example.com)",
-	}
-
-	rl := rate.NewLimiter(rate.Limit(1000), 1000)
-	client := &MusicBrainzClient{
-		httpClient:  server.Client(),
-		userAgent:   cfg.UserAgent,
-		baseURL:     server.URL,
-		rateLimiter: rl,
-	}
-
-	_, err := client.doGet(context.Background(), "/test")
-	if err == nil {
-		t.Fatal("doGet() expected error for unreachable server, got nil")
-	}
-}
-
-func TestDoGet_ContextCancellation(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Write([]byte(`<metadata><test>ok</test></metadata>`))
-	}))
-	defer server.Close()
-
-	cfg := config.MusicBrainzConfig{
-		UserAgent: "naviwatcher/0.1.0 (test@example.com)",
-	}
-
-	// Use a rate limiter with 0 burst to force blocking on Wait
-	rl := rate.NewLimiter(rate.Limit(0), 0)
-	client := &MusicBrainzClient{
-		httpClient:  server.Client(),
-		userAgent:   cfg.UserAgent,
-		baseURL:     server.URL,
-		rateLimiter: rl,
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel() // cancel immediately
-
-	_, err := client.doGet(ctx, "/test")
-	if err == nil {
-		t.Fatal("doGet() expected error for cancelled context, got nil")
-	}
-}
-
-func TestRateLimiter_OnePerSecond(t *testing.T) {
-	// Verify that the rate limiter enforces approximately 1 request per second
-	rl := rate.NewLimiter(rate.Limit(1), 1)
-
-	// First request should be immediate (burst of 1)
-	start := time.Now()
-	if err := rl.Wait(context.Background()); err != nil {
-		t.Fatalf("first Wait() error: %v", err)
-	}
-	elapsed := time.Since(start)
-	if elapsed > 200*time.Millisecond {
-		t.Errorf("first Wait() took %v, expected near-instant", elapsed)
-	}
-
-	// Second request should block for approximately 1 second
-	start = time.Now()
-	if err := rl.Wait(context.Background()); err != nil {
-		t.Fatalf("second Wait() error: %v", err)
-	}
-	elapsed = time.Since(start)
-	if elapsed < 800*time.Millisecond {
-		t.Errorf("second Wait() took %v, expected at least ~1s", elapsed)
-	}
-	if elapsed > 2*time.Second {
-		t.Errorf("second Wait() took %v, expected less than 2s", elapsed)
-	}
-}
-
-func TestRateLimiter_BurstBehavior(t *testing.T) {
-	// With burst=1, the first request should be immediate
-	rl := rate.NewLimiter(rate.Limit(1), 1)
-
-	start := time.Now()
-	rl.Wait(context.Background())
-	elapsed := time.Since(start)
-
-	if elapsed > 200*time.Millisecond {
-		t.Errorf("burst Wait() took %v, expected near-instant", elapsed)
-	}
-}

internal/musicbrainz/filter.go

@@ -1,106 +0,0 @@
-package musicbrainz
-
-import (
-	"naviwatcher/internal/database"
-)
-
-// FilterOptions holds per-artist type filtering preferences.
-type FilterOptions struct {
-	IgnoreSingles      bool
-	IgnoreCompilations bool
-	IgnoreLive         bool
-	IgnoreRemix        bool
-}
-
-// hasSliceType reports whether the slice contains any of the wanted values.
-func hasSliceType(types []string, wanted ...string) bool {
-	for _, s := range types {
-		for _, w := range wanted {
-			if s == w {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// ApplyTypeToggles filters releases based on the IgnoreSingles and IgnoreCompilations flags.
-// Implements canonical filtering logic:
-//
-//	IgnoreSingles filters: Type == "Single" OR Type == "EP" OR SecondaryTypes contains "Single" OR "EP"
-//	IgnoreCompilations filters: Type == "Compilation" OR SecondaryTypes contains "Compilation"
-//	IgnoreLive filters: Type == "Live" OR SecondaryTypes contains "Live"
-//	IgnoreRemix filters: Type == "Remix" OR SecondaryTypes contains "Remix"
-func ApplyTypeToggles(releases []database.ExternalRelease, opts FilterOptions) []database.ExternalRelease {
-	var result []database.ExternalRelease
-	for _, release := range releases {
-		// Apply IgnoreSingles filtering: filter out if Type is Single/EP OR SecondaryTypes contains Single/EP
-		if opts.IgnoreSingles {
-			if release.Type == "Single" || release.Type == "EP" || hasSliceType(release.SecondaryTypes, "Single", "EP") {
-				continue
-			}
-		}
-
-		// Apply IgnoreCompilations filtering: filter out if Type is Compilation OR SecondaryTypes contains Compilation
-		if opts.IgnoreCompilations {
-			if release.Type == "Compilation" || hasSliceType(release.SecondaryTypes, "Compilation") {
-				continue
-			}
-		}
-
-		// Apply IgnoreLive filtering: filter out if Type is Live OR SecondaryTypes contains Live
-		if opts.IgnoreLive {
-			if release.Type == "Live" || hasSliceType(release.SecondaryTypes, "Live") {
-				continue
-			}
-		}
-
-		// Apply IgnoreRemix filtering: filter out if Type is Remix OR SecondaryTypes contains Remix
-		if opts.IgnoreRemix {
-			if release.Type == "Remix" || hasSliceType(release.SecondaryTypes, "Remix") {
-				continue
-			}
-		}
-
-		result = append(result, release)
-	}
-	return result
-}
-
-// ApplyTypeTogglesToReleaseGroups applies the same IgnoreSingles/IgnoreCompinators filtering logic
-// to a slice of ReleaseGroup objects.
-func ApplyTypeTogglesToReleaseGroups(groups []ReleaseGroup, opts FilterOptions) []ReleaseGroup {
-	var result []ReleaseGroup
-	for _, rg := range groups {
-		// Apply IgnoreSingles filtering: filter out if Type is Single/EP OR SecondaryTypes contains Single/EP
-		if opts.IgnoreSingles {
-			if rg.Type == "Single" || rg.Type == "EP" || hasSliceType(rg.SecondaryTypes, "Single", "EP") {
-				continue
-			}
-		}
-
-		// Apply IgnoreCompilations filtering: filter out if Type is Compilation OR SecondaryTypes contains Compilation
-		if opts.IgnoreCompilations {
-			if rg.Type == "Compilation" || hasSliceType(rg.SecondaryTypes, "Compilation") {
-				continue
-			}
-		}
-
-		// Apply IgnoreLive filtering: filter out if Type is Live OR SecondaryTypes contains Live
-		if opts.IgnoreLive {
-			if rg.Type == "Live" || hasSliceType(rg.SecondaryTypes, "Live") {
-				continue
-			}
-		}
-
-		// Apply IgnoreRemix filtering: filter out if Type is Remix OR SecondaryTypes contains Remix
-		if opts.IgnoreRemix {
-			if rg.Type == "Remix" || hasSliceType(rg.SecondaryTypes, "Remix") {
-				continue
-			}
-		}
-
-		result = append(result, rg)
-	}
-	return result
-}

internal/musicbrainz/filter_test.go

@@ -1,186 +0,0 @@
-package musicbrainz_test
-
-import (
-	"testing"
-
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/musicbrainz"
-)
-
-func TestApplyTypeToggles(t *testing.T) {
-	releases := []database.ExternalRelease{
-		{RGID: "r1", Type: "Single", SecondaryTypes: []string{}},
-		{RGID: "r2", Type: "Album", SecondaryTypes: []string{"Single"}},
-		{RGID: "r3", Type: "Compilation", SecondaryTypes: []string{}},
-		{RGID: "r4", Type: "Album", SecondaryTypes: []string{"Compilation"}},
-		{RGID: "r5", Type: "EP", SecondaryTypes: []string{}},
-		{RGID: "r6", Type: "Album", SecondaryTypes: []string{"EP"}},
-		{RGID: "r7", Type: "Live", SecondaryTypes: []string{}},
-		{RGID: "r8", Type: "Album", SecondaryTypes: []string{"Live"}},
-		{RGID: "r9", Type: "Remix", SecondaryTypes: []string{}},
-		{RGID: "r10", Type: "Album", SecondaryTypes: []string{"Remix"}},
-	}
-
-	tests := []struct {
-		name           string
-		opts           musicbrainz.FilterOptions
-		expectedCounts int
-		expectedRGIDs  []string
-	}{
-		{
-			name:           "No filters",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: false, IgnoreCompilations: false, IgnoreLive: false, IgnoreRemix: false},
-			expectedCounts: 10,
-			expectedRGIDs:  []string{"r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10"},
-		},
-		{
-			name:           "Ignore singles only",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: true, IgnoreCompilations: false, IgnoreLive: false, IgnoreRemix: false},
-			// Actually: r1(Single), r2(Album+Single), r5(EP), r6(Album+EP) should be filtered out
-			// Leaving: r3(Compilation), r4(Album+Compilation), r7(Live), r8(Album+Live), r9(Remix), r10(Album+Remix)
-			expectedCounts: 6,
-			expectedRGIDs:  []string{"r3", "r4", "r7", "r8", "r9", "r10"},
-		},
-		{
-			name:           "Ignore compilations only",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: false, IgnoreCompilations: true, IgnoreLive: false, IgnoreRemix: false},
-			// r1, r2, r5, r6, r7, r8, r9, r10 (r3 and r4 filtered out)
-			expectedCounts: 8,
-			expectedRGIDs:  []string{"r1", "r2", "r5", "r6", "r7", "r8", "r9", "r10"},
-		},
-		{
-			name:           "Ignore live only",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: false, IgnoreCompilations: false, IgnoreLive: true, IgnoreRemix: false},
-			// r1, r2, r3, r4, r5, r6, r9, r10 (r7 and r8 filtered out)
-			expectedCounts: 8,
-			expectedRGIDs:  []string{"r1", "r2", "r3", "r4", "r5", "r6", "r9", "r10"},
-		},
-		{
-			name:           "Ignore remix only",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: false, IgnoreCompilations: false, IgnoreLive: false, IgnoreRemix: true},
-			// r1, r2, r3, r4, r5, r6, r7, r8 (r9 and r10 filtered out)
-			expectedCounts: 8,
-			expectedRGIDs:  []string{"r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8"},
-		},
-		{
-			name:           "Ignore both singles and compilations",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: true, IgnoreCompilations: true, IgnoreLive: false, IgnoreRemix: false},
-			// Actually: r1, r2, r5, r6 filtered (singles) and r3, r4 filtered (compilations)
-			// Leaving: r7(Live), r8(Album+Live), r9(Remix), r10(Album+Remix)
-			expectedCounts: 4,
-			expectedRGIDs:  []string{"r7", "r8", "r9", "r10"},
-		},
-		{
-			name:           "Ignore live and remix",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: false, IgnoreCompilations: false, IgnoreLive: true, IgnoreRemix: true},
-			// r1, r2, r3, r4, r5, r6 (r7, r8, r9, r10 filtered out)
-			expectedCounts: 6,
-			expectedRGIDs:  []string{"r1", "r2", "r3", "r4", "r5", "r6"},
-		},
-		{
-			name:           "Ignore all four types",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: true, IgnoreCompilations: true, IgnoreLive: true, IgnoreRemix: true},
-			expectedCounts: 0,
-			expectedRGIDs:  []string{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := musicbrainz.ApplyTypeToggles(releases, tt.opts)
-			if len(got) != tt.expectedCounts {
-				t.Errorf("expected %d releases, got %d", tt.expectedCounts, len(got))
-			}
-			for i, r := range got {
-				if r.RGID != tt.expectedRGIDs[i] {
-					t.Errorf("expected RGID %s at index %d, got %s", tt.expectedRGIDs[i], i, r.RGID)
-				}
-			}
-		})
-	}
-}
-
-func TestApplyTypeTogglesToReleaseGroups(t *testing.T) {
-	groups := []musicbrainz.ReleaseGroup{
-		{ID: "g1", Type: "Single", SecondaryTypes: []string{}},
-		{ID: "g2", Type: "Album", SecondaryTypes: []string{"Single"}},
-		{ID: "g3", Type: "Compilation", SecondaryTypes: []string{}},
-		{ID: "g4", Type: "Album", SecondaryTypes: []string{"Compilation"}},
-		{ID: "g5", Type: "EP", SecondaryTypes: []string{}},
-		{ID: "g6", Type: "Album", SecondaryTypes: []string{"EP"}},
-		{ID: "g7", Type: "Live", SecondaryTypes: []string{}},
-		{ID: "g8", Type: "Album", SecondaryTypes: []string{"Live"}},
-		{ID: "g9", Type: "Remix", SecondaryTypes: []string{}},
-		{ID: "g10", Type: "Album", SecondaryTypes: []string{"Remix"}},
-	}
-
-	tests := []struct {
-		name           string
-		opts           musicbrainz.FilterOptions
-		expectedCounts int
-		expectedIDs    []string
-	}{
-		{
-			name:           "No filters",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: false, IgnoreCompilations: false, IgnoreLive: false, IgnoreRemix: false},
-			expectedCounts: 10,
-			expectedIDs:    []string{"g1", "g2", "g3", "g4", "g5", "g6", "g7", "g8", "g9", "g10"},
-		},
-		{
-			name:           "Ignore singles only",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: true, IgnoreCompilations: false, IgnoreLive: false, IgnoreRemix: false},
-			expectedCounts: 6,
-			expectedIDs:    []string{"g3", "g4", "g7", "g8", "g9", "g10"},
-		},
-		{
-			name:           "Ignore compilations only",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: false, IgnoreCompilations: true, IgnoreLive: false, IgnoreRemix: false},
-			expectedCounts: 8, // g1, g2, g5, g6, g7, g8, g9, g10 (g3 and g4 filtered out)
-			expectedIDs:    []string{"g1", "g2", "g5", "g6", "g7", "g8", "g9", "g10"},
-		},
-		{
-			name:           "Ignore live only",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: false, IgnoreCompilations: false, IgnoreLive: true, IgnoreRemix: false},
-			expectedCounts: 8, // g1, g2, g3, g4, g5, g6, g9, g10 (g7 and g8 filtered out)
-			expectedIDs:    []string{"g1", "g2", "g3", "g4", "g5", "g6", "g9", "g10"},
-		},
-		{
-			name:           "Ignore remix only",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: false, IgnoreCompilations: false, IgnoreLive: false, IgnoreRemix: true},
-			expectedCounts: 8, // g1, g2, g3, g4, g5, g6, g7, g8 (g9 and g10 filtered out)
-			expectedIDs:    []string{"g1", "g2", "g3", "g4", "g5", "g6", "g7", "g8"},
-		},
-		{
-			name:           "Ignore both singles and compilations",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: true, IgnoreCompilations: true, IgnoreLive: false, IgnoreRemix: false},
-			expectedCounts: 4,
-			expectedIDs:    []string{"g7", "g8", "g9", "g10"},
-		},
-		{
-			name:           "Ignore live and remix",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: false, IgnoreCompilations: false, IgnoreLive: true, IgnoreRemix: true},
-			expectedCounts: 6, // g1, g2, g3, g4, g5, g6 (g7, g8, g9, g10 filtered out)
-			expectedIDs:    []string{"g1", "g2", "g3", "g4", "g5", "g6"},
-		},
-		{
-			name:           "Ignore all four types",
-			opts:           musicbrainz.FilterOptions{IgnoreSingles: true, IgnoreCompilations: true, IgnoreLive: true, IgnoreRemix: true},
-			expectedCounts: 0,
-			expectedIDs:    []string{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := musicbrainz.ApplyTypeTogglesToReleaseGroups(groups, tt.opts)
-			if len(got) != tt.expectedCounts {
-				t.Errorf("expected %d groups, got %d", tt.expectedCounts, len(got))
-			}
-			for i, g := range got {
-				if g.ID != tt.expectedIDs[i] {
-					t.Errorf("expected ID %s at index %d, got %s", tt.expectedIDs[i], i, g.ID)
-				}
-			}
-		})
-	}
-}

internal/musicbrainz/model.go

@@ -1,26 +0,0 @@
-package musicbrainz
-
-// ReleaseGroup represents a MusicBrainz Release Group entity.
-// This is the primary data model for the provider - we work with
-// Release Groups to minimize duplicates from different releases.
-//
-// Type holds the primary type (Album, Single, EP, Other, Broadcast, ...).
-// SecondaryTypes holds secondary type classifications (Live, Compilation,
-// Remix, ...). Together they drive the scanner's type filtering; release
-// groups have no status, so there is no Status field.
-type ReleaseGroup struct {
-	ID             string
-	Title          string
-	Type           string
-	SecondaryTypes []string
-	ArtistID       string
-	ArtistName     string
-	ReleaseDate    string
-}
-
-// ParsedReleaseGroups holds the result of parsing a MusicBrainz
-// release-group list XML response.
-type ParsedReleaseGroups struct {
-	ReleaseGroups []ReleaseGroup
-	Count         int
-}

internal/musicbrainz/model_test.go

@@ -1,215 +0,0 @@
-package musicbrainz
-
-import (
-	"testing"
-)
-
-func TestParseReleaseGroups_Success(t *testing.T) {
-	data := []byte(`<?xml version="1.0" encoding="UTF-8"?>
-<metadata xmlns="http://musicbrainz.org/ns/mmd-2.0#">
-  <release-group-list count="2">
-    <release-group id="rg-uuid-1" type="Album">
-      <title>Dark Side of the Moon</title>
-      <first-release-date>1973-03-01</first-release-date>
-      <artist-credit>
-        <name-credit>
-          <artist id="artist-uuid-1">
-            <name>Pink Floyd</name>
-          </artist>
-        </name-credit>
-      </artist-credit>
-    </release-group>
-    <release-group id="rg-uuid-2" type="Single">
-      <title>Another Brick in the Wall</title>
-      <first-release-date>1979-11-30</first-release-date>
-      <artist-credit>
-        <name-credit>
-          <artist id="artist-uuid-1">
-            <name>Pink Floyd</name>
-          </artist>
-        </name-credit>
-      </artist-credit>
-    </release-group>
-  </release-group-list>
-</metadata>`)
-
-	result, err := ParseReleaseGroups(data)
-	if err != nil {
-		t.Fatalf("ParseReleaseGroups() error = %v", err)
-	}
-
-	if result.Count != 2 {
-		t.Errorf("ParseReleaseGroups().Count = %d, want 2", result.Count)
-	}
-
-	if len(result.ReleaseGroups) != 2 {
-		t.Fatalf("ParseReleaseGroups() returned %d groups, want 2", len(result.ReleaseGroups))
-	}
-
-	expected := []ReleaseGroup{
-		{
-			ID:          "rg-uuid-1",
-			Title:       "Dark Side of the Moon",
-			Type:        "Album",
-			ArtistID:    "artist-uuid-1",
-			ArtistName:  "Pink Floyd",
-			ReleaseDate: "1973-03-01",
-		},
-		{
-			ID:          "rg-uuid-2",
-			Title:       "Another Brick in the Wall",
-			Type:        "Single",
-			ArtistID:    "artist-uuid-1",
-			ArtistName:  "Pink Floyd",
-			ReleaseDate: "1979-11-30",
-		},
-	}
-
-	for i, rg := range result.ReleaseGroups {
-		if rg.ID != expected[i].ID {
-			t.Errorf("ReleaseGroups[%d].ID = %q, want %q", i, rg.ID, expected[i].ID)
-		}
-		if rg.Title != expected[i].Title {
-			t.Errorf("ReleaseGroups[%d].Title = %q, want %q", i, rg.Title, expected[i].Title)
-		}
-		if rg.Type != expected[i].Type {
-			t.Errorf("ReleaseGroups[%d].Type = %q, want %q", i, rg.Type, expected[i].Type)
-		}
-		if rg.ArtistID != expected[i].ArtistID {
-			t.Errorf("ReleaseGroups[%d].ArtistID = %q, want %q", i, rg.ArtistID, expected[i].ArtistID)
-		}
-		if rg.ArtistName != expected[i].ArtistName {
-			t.Errorf("ReleaseGroups[%d].ArtistName = %q, want %q", i, rg.ArtistName, expected[i].ArtistName)
-		}
-		if rg.ReleaseDate != expected[i].ReleaseDate {
-			t.Errorf("ReleaseGroups[%d].ReleaseDate = %q, want %q", i, rg.ReleaseDate, expected[i].ReleaseDate)
-		}
-	}
-}
-
-func TestParseReleaseGroups_Empty(t *testing.T) {
-	data := []byte(`<?xml version="1.0" encoding="UTF-8"?>
-<metadata xmlns="http://musicbrainz.org/ns/mmd-2.0#">
-  <release-group-list count="0">
-  </release-group-list>
-</metadata>`)
-
-	result, err := ParseReleaseGroups(data)
-	if err != nil {
-		t.Fatalf("ParseReleaseGroups() error = %v", err)
-	}
-
-	if result.Count != 0 {
-		t.Errorf("ParseReleaseGroups().Count = %d, want 0", result.Count)
-	}
-
-	if len(result.ReleaseGroups) != 0 {
-		t.Errorf("ParseReleaseGroups() returned %d groups, want 0", len(result.ReleaseGroups))
-	}
-}
-
-func TestParseReleaseGroups_MalformedXML(t *testing.T) {
-	tests := []struct {
-		name string
-		data []byte
-	}{
-		{
-			name: "truncated XML",
-			data: []byte(`<?xml version="1.0"?><metadata><release-group-list>`),
-		},
-		{
-			name: "not XML at all",
-			data: []byte(`this is not xml`),
-		},
-		{
-			name: "wrong root element",
-			data: []byte(`<?xml version="1.0"?><wrongRoot><item>test</item></wrongRoot>`),
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := ParseReleaseGroups(tt.data)
-			if err == nil {
-				t.Fatal("ParseReleaseGroups() expected error for malformed XML, got nil")
-			}
-		})
-	}
-}
-
-func TestParseReleaseGroups_PrimaryAndSecondaryTypes(t *testing.T) {
-	data := []byte(`<?xml version="1.0" encoding="UTF-8"?>
-<metadata xmlns="http://musicbrainz.org/ns/mmd-2.0#">
-  <release-group-list count="2">
-    <release-group id="rg-album" type="Album">
-      <title>Studio Album</title>
-      <primary-type>Album</primary-type>
-      <first-release-date>2020-01-01</first-release-date>
-      <artist-credit>
-        <name-credit>
-          <artist id="artist-uuid-2">
-            <name>Test Artist</name>
-          </artist>
-        </name-credit>
-      </artist-credit>
-    </release-group>
-    <release-group id="rg-comp" type="Album Compilation">
-      <title>Greatest Hits</title>
-      <primary-type>Album</primary-type>
-      <secondary-type-list>
-        <secondary-type>Compilation</secondary-type>
-        <secondary-type>Live</secondary-type>
-      </secondary-type-list>
-      <first-release-date>2021-05-05</first-release-date>
-      <artist-credit>
-        <name-credit>
-          <artist id="artist-uuid-2">
-            <name>Test Artist</name>
-          </artist>
-        </name-credit>
-      </artist-credit>
-    </release-group>
-  </release-group-list>
-</metadata>`)
-
-	result, err := ParseReleaseGroups(data)
-	if err != nil {
-		t.Fatalf("ParseReleaseGroups() error = %v", err)
-	}
-
-	if len(result.ReleaseGroups) != 2 {
-		t.Fatalf("ParseReleaseGroups() returned %d groups, want 2", len(result.ReleaseGroups))
-	}
-
-	byID := make(map[string]ReleaseGroup)
-	for _, rg := range result.ReleaseGroups {
-		byID[rg.ID] = rg
-	}
-
-	album := byID["rg-album"]
-	if album.Type != "Album" {
-		t.Errorf("rg-album.Type = %q, want %q", album.Type, "Album")
-	}
-	if len(album.SecondaryTypes) != 0 {
-		t.Errorf("rg-album.SecondaryTypes = %v, want empty", album.SecondaryTypes)
-	}
-
-	comp := byID["rg-comp"]
-	if comp.Type != "Album" {
-		t.Errorf("rg-comp.Type = %q, want %q", comp.Type, "Album")
-	}
-	// Release groups have no status attribute; the secondary type list is the
-	// authoritative source for classifications like Compilation.
-	if !contains(comp.SecondaryTypes, "Compilation") || !contains(comp.SecondaryTypes, "Live") {
-		t.Errorf("rg-comp.SecondaryTypes = %v, want Compilation and Live", comp.SecondaryTypes)
-	}
-}
-
-func contains(s []string, want string) bool {
-	for _, v := range s {
-		if v == want {
-			return true
-		}
-	}
-	return false
-}

internal/musicbrainz/resolve.go

@@ -1,70 +0,0 @@
-package musicbrainz
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/url"
-
-	"naviwatcher/internal/normalize"
-)
-
-// mbArtistSearchResult models the JSON response of the MusicBrainz artist
-// search endpoint (/ws/2/artist?query=artist:<name>&fmt=json). Only the
-// fields we need for MBID resolution are decoded.
-type mbArtistSearchResult struct {
-	Artists []struct {
-		ID    string `json:"id"`
-		Name  string `json:"name"`
-		Score int    `json:"score"`
-	} `json:"artists"`
-}
-
-// minResolutionScore is the minimum MusicBrainz search score (0-100) we accept
-// for an MBID resolution. Below this, the best hit is too weak a match to
-// trust, and caching it would silently pollute an artist's discography with
-// the wrong MusicBrainz data.
-const minResolutionScore = 80
-
-// ResolveArtistMBID resolves a MusicBrainz artist ID (MBID) for the given
-// artist name by querying the MusicBrainz artist search endpoint. It returns
-// the ID of the highest-scoring matching artist, but only when that artist's
-// normalized name actually matches the requested name (and its search score is
-// at or above minResolutionScore). An error is returned if the search yields
-// no usable match, the response cannot be parsed, or the underlying request
-// fails. Rejecting a low-confidence hit lets the caller surface the problem
-// instead of caching a wrong MBID.
-func (c *MusicBrainzClient) ResolveArtistMBID(ctx context.Context, name string) (string, error) {
-	params := url.Values{}
-	params.Set("query", fmt.Sprintf("artist:%s", name))
-	params.Set("fmt", "json")
-	path := "/artist?" + params.Encode()
-
-	body, err := c.doGet(ctx, path)
-	if err != nil {
-		return "", fmt.Errorf("resolve MBID for artist %q: %w", name, err)
-	}
-
-	var result mbArtistSearchResult
-	if err := json.Unmarshal(body, &result); err != nil {
-		return "", fmt.Errorf("parse artist search response for %q: %w", name, err)
-	}
-
-	if len(result.Artists) == 0 {
-		return "", fmt.Errorf("no MusicBrainz artist found for %q", name)
-	}
-
-	best := result.Artists[0]
-	if best.Score < minResolutionScore {
-		return "", fmt.Errorf("no confident MusicBrainz match for %q (best candidate %q scored %d, need >= %d)", name, best.Name, best.Score, minResolutionScore)
-	}
-	// Even with a high score, require the normalized name to match, guarding
-	// against score inflation on name collisions (e.g. tribute acts).
-	if normalize.NormalizeArtistName(best.Name) != normalize.NormalizeArtistName(name) {
-		log.Printf("MusicBrainz MBID resolution skipped for %q: best candidate %q did not match by name", name, best.Name)
-		return "", fmt.Errorf("best MusicBrainz candidate %q does not match %q by name", best.Name, name)
-	}
-
-	return best.ID, nil
-}

internal/musicbrainz/resolve_test.go

@@ -1,105 +0,0 @@
-package musicbrainz
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-)
-
-// newTestClient is defined in sync_test.go (signature: func newTestClient(serverURL string) *MusicBrainzClient).
-// contains is defined in model_test.go (signature: func contains(s []string, want string) bool).
-
-func TestResolveArtistMBID_MatchFound(t *testing.T) {
-	var gotPath string
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotPath = r.URL.RequestURI()
-		w.Header().Set("Content-Type", "application/json")
-		_ = json.NewEncoder(w).Encode(mbArtistSearchResult{
-			Artists: []struct {
-				ID    string `json:"id"`
-				Name  string `json:"name"`
-				Score int    `json:"score"`
-			}{
-				{ID: "f27a7a7e-5a47-4cd5-afbe-6b7b01672b3b", Name: "Radiohead", Score: 100},
-				{ID: "another-id", Name: "Radiohead (Tribute)", Score: 80},
-			},
-		})
-	}))
-	defer server.Close()
-
-	client := newTestClient(server.URL)
-
-	mbid, err := client.ResolveArtistMBID(context.Background(), "Radiohead")
-	if err != nil {
-		t.Fatalf("ResolveArtistMBID() error = %v", err)
-	}
-
-	want := "f27a7a7e-5a47-4cd5-afbe-6b7b01672b3b"
-	if mbid != want {
-		t.Errorf("ResolveArtistMBID() = %q, want %q", mbid, want)
-	}
-
-	// Verify the request used the expected query path and JSON format.
-	if gotPath == "" || !strings.Contains(gotPath, "/artist?") {
-		t.Errorf("ResolveArtistMBID() requested path = %q, want /artist?...", gotPath)
-	}
-	if !strings.Contains(gotPath, "query=artist%3ARadiohead") {
-		t.Errorf("ResolveArtistMBID() query missing artist name, got %q", gotPath)
-	}
-	if !strings.Contains(gotPath, "fmt=json") {
-		t.Errorf("ResolveArtistMBID() query missing fmt=json, got %q", gotPath)
-	}
-
-}
-
-func TestResolveArtistMBID_NoMatch(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		_ = json.NewEncoder(w).Encode(mbArtistSearchResult{Artists: []struct {
-			ID    string `json:"id"`
-			Name  string `json:"name"`
-			Score int    `json:"score"`
-		}{}})
-	}))
-	defer server.Close()
-
-	client := newTestClient(server.URL)
-
-	_, err := client.ResolveArtistMBID(context.Background(), "Nonexistent Artist 12345")
-	if err == nil {
-		t.Fatal("ResolveArtistMBID() expected error for no match, got nil")
-	}
-}
-
-func TestResolveArtistMBID_HTTPError(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusServiceUnavailable)
-		w.Write([]byte("Service Unavailable"))
-	}))
-	defer server.Close()
-
-	client := newTestClient(server.URL)
-
-	_, err := client.ResolveArtistMBID(context.Background(), "Radiohead")
-	if err == nil {
-		t.Fatal("ResolveArtistMBID() expected error on HTTP failure, got nil")
-	}
-}
-
-func TestResolveArtistMBID_InvalidJSON(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		w.Write([]byte(`not valid json`))
-	}))
-	defer server.Close()
-
-	client := newTestClient(server.URL)
-
-	_, err := client.ResolveArtistMBID(context.Background(), "Radiohead")
-	if err == nil {
-		t.Fatal("ResolveArtistMBID() expected parse error, got nil")
-	}
-}

internal/musicbrainz/sync.go

@@ -1,248 +0,0 @@
-package musicbrainz
-
-import (
-	"context"
-	"database/sql"
-	"fmt"
-	"strings"
-	"time"
-
-	"naviwatcher/internal/database"
-)
-
-// SyncArtistDiscography synchronizes an artist's discography from MusicBrainz
-// into the local external_releases table. It follows this flow:
-//  1. Check if cached data exists and is within TTL.
-//  2. If cache hit, return the cached releases immediately.
-//  3. If cache miss or expired, fetch release groups from MusicBrainz API.
-//  4. Apply status and type filtering.
-//  5. Within a transaction: delete old entries, then upsert each filtered release group.
-//  6. Return the list of external releases.
-//
-// artistID is the canonical artist key from artist_settings (the Navidrome
-// artist ID). It is stored as external_releases.artist_id so that the foreign
-// key to artist_settings and the scanner's join on ArtistID resolve correctly.
-// artistMBID is the MusicBrainz ID used only to query the MusicBrainz API.
-//
-// Context cancellation is checked before the API call and between each upsert
-// to allow graceful interruption.
-func SyncArtistDiscography(
-	ctx context.Context,
-	client *MusicBrainzClient,
-	db *database.DB,
-	artistID string,
-	artistMBID string,
-	ttl time.Duration,
-) ([]database.ExternalRelease, error) {
-	// Check context before starting.
-	if err := ctx.Err(); err != nil {
-		return nil, fmt.Errorf("sync artist discography: %w", err)
-	}
-
-	// Step 1: Check cache freshness. A genuine hit means the artist was synced
-	// within the TTL — even when it has zero release groups. We must not gate on
-	// row count, or artists with an empty MusicBrainz discography would be
-	// re-fetched on every sync (defeating the TTL and wasting the 1 req/s budget).
-	cachedReleases, err := database.GetExternalReleasesByArtistWithCache(db, artistID, ttl)
-	if err != nil {
-		return nil, fmt.Errorf("sync artist discography: cache check failed: %w", err)
-	}
-	fresh, err := database.ArtistCacheFresh(db, artistID, ttl)
-	if err != nil {
-		return nil, fmt.Errorf("sync artist discography: cache freshness check failed: %w", err)
-	}
-
-	// Step 2: If we have a fresh cache, return the cached data. Re-apply the
-	// per-artist type toggles even on a cache hit so user changes to
-	// ignore_singles / ignore_compilations take effect without waiting for cache
-	// expiry. (Status/type inclusion was already applied when the rows were first
-	// synced and stored, so only the toggles can change.)
-	//
-	// The MusicBrainz sync path applies filtering at store-time (when caching
-	// release groups from the API), while the scanner path applies filtering at
-	// read-time (when retrieving cached data). This dual-path approach ensures:
-	// 1. Storage efficiency: filtered results are stored, reducing database size
-	// 2. Real-time responsiveness: changes to ignore_singles/ignore_compilations
-	//    take effect immediately without waiting for cache expiry
-	// 3. Consistency: both paths use the same filtering logic via
-	//    musicbrainz.ApplyTypeToggles
-	if fresh {
-		if err := ctx.Err(); err != nil {
-			return nil, fmt.Errorf("sync artist discography: %w", err)
-		}
-		opts, err := getArtistFilterOptions(db, artistID)
-		if err != nil {
-			return nil, fmt.Errorf("sync artist discography: read artist filter options: %w", err)
-		}
-		filtered := ApplyTypeToggles(cachedReleases, opts)
-		return filtered, nil
-	}
-
-	// Step 3: Cache miss — fetch from MusicBrainz API.
-	groups, err := client.GetArtistReleaseGroups(ctx, artistMBID)
-	if err != nil {
-		return nil, fmt.Errorf("sync artist discography: fetch release groups for artist %s: %w", artistMBID, err)
-	}
-
-	// Step 4: Apply filtering with per-artist type preferences.
-	opts, err := getArtistFilterOptions(db, artistID)
-	if err != nil {
-		return nil, fmt.Errorf("sync artist discography: read artist filter options: %w", err)
-	}
-	filtered := FilterReleaseGroups(groups, opts)
-
-	// Step 5: Upsert within a transaction — delete old entries first, then insert new ones.
-	now := time.Now().UTC()
-	tx, err := db.Begin()
-	if err != nil {
-		return nil, fmt.Errorf("sync artist discography: begin transaction: %w", err)
-	}
-	defer tx.Rollback()
-
-	// Read existing ignore states before deleting to preserve user-set flags.
-	ignoredMap := map[string]bool{}
-	rows, err := tx.Query("SELECT rgid, is_ignored FROM external_releases WHERE artist_id = ?", artistID)
-	if err != nil {
-		return nil, fmt.Errorf("sync artist discography: query existing releases: %w", err)
-	}
-	for rows.Next() {
-		var rgid string
-		var ignored bool
-		if err := rows.Scan(&rgid, &ignored); err != nil {
-			rows.Close()
-			return nil, fmt.Errorf("sync artist discography: scan existing release: %w", err)
-		}
-		ignoredMap[rgid] = ignored
-	}
-	if err := rows.Err(); err != nil {
-		rows.Close()
-		return nil, fmt.Errorf("sync artist discography: iterate existing releases: %w", err)
-	}
-	rows.Close()
-
-	// Build the set of RGIDs present in this sync so we can drop only the rows
-	// that disappeared, leaving the rest (and their notification markers) intact.
-	synced := make([]string, 0, len(filtered))
-	for _, rg := range filtered {
-		synced = append(synced, rg.ID)
-	}
-
-	// Drop notification markers for releases that are gone. This runs before the
-	// external_releases delete so the FK on notifications_sent.rgid stays valid
-	// (we only ever delete from notifications_sent here).
-	// Process in chunks to avoid SQLite parameter limits (default limit is 999).
-	if len(synced) > 0 {
-		const chunkSize = 500
-		for i := 0; i < len(synced); i += chunkSize {
-			end := i + chunkSize
-			if end > len(synced) {
-				end = len(synced)
-			}
-			chunk := synced[i:end]
-
-			placeholders := strings.Repeat("?,", len(chunk))
-			placeholders = placeholders[:len(placeholders)-1]
-			query := fmt.Sprintf(
-				"DELETE FROM notifications_sent WHERE rgid IN (SELECT rgid FROM external_releases WHERE artist_id = ? AND rgid NOT IN (%s))",
-				placeholders,
-			)
-			args := make([]any, 1+len(chunk))
-			args[0] = artistID
-			for i, v := range chunk {
-				args[i+1] = v
-			}
-			if _, err := tx.Exec(query, args...); err != nil {
-				return nil, fmt.Errorf("sync artist discography: prune stale notifications (chunk %d-%d): %w", i, end, err)
-			}
-		}
-
-		// Remove external_release rows that are no longer part of the discography.
-		// Process in chunks to avoid SQLite parameter limits.
-		for i := 0; i < len(synced); i += chunkSize {
-			end := i + chunkSize
-			if end > len(synced) {
-				end = len(synced)
-			}
-			chunk := synced[i:end]
-
-			placeholders := strings.Repeat("?,", len(chunk))
-			placeholders = placeholders[:len(placeholders)-1]
-			delQuery := fmt.Sprintf(
-				"DELETE FROM external_releases WHERE artist_id = ? AND rgid NOT IN (%s)",
-				placeholders,
-			)
-			args := make([]any, 1+len(chunk))
-			args[0] = artistID
-			for i, v := range chunk {
-				args[i+1] = v
-			}
-			if _, err := tx.Exec(delQuery, args...); err != nil {
-				return nil, fmt.Errorf("sync artist discography: delete stale releases (chunk %d-%d): %w", i, end, err)
-			}
-		}
-	} else {
-		// No releases this sync: the artist may have an empty discography. Drop
-		// everything we previously cached for them.
-		if _, err := tx.Exec("DELETE FROM notifications_sent WHERE rgid IN (SELECT rgid FROM external_releases WHERE artist_id = ?)", artistID); err != nil {
-			return nil, fmt.Errorf("sync artist discography: delete notifications: %w", err)
-		}
-		if _, err := tx.Exec("DELETE FROM external_releases WHERE artist_id = ?", artistID); err != nil {
-			return nil, fmt.Errorf("sync artist discography: delete old releases: %w", err)
-		}
-	}
-
-	var releases []database.ExternalRelease
-	for _, rg := range filtered {
-		// Check context cancellation between each upsert.
-		if err := ctx.Err(); err != nil {
-			return nil, fmt.Errorf("sync artist discography: %w", err)
-		}
-
-		ext := rg.ToExternalRelease(artistID)
-		ext.CachedAt = now
-		// Preserve user-set ignore flag from previous sync.
-		if ignored, ok := ignoredMap[ext.RGID]; ok {
-			ext.IsIgnored = ignored
-		}
-
-		if _, err := tx.Exec(
-			"INSERT OR REPLACE INTO external_releases (rgid, artist_id, title, type, release_date, is_ignored, cached_at, secondary_types) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-			ext.RGID, ext.ArtistID, ext.Title, ext.Type, ext.ReleaseDate, ext.IsIgnored, database.FormatCachedAt(ext.CachedAt), database.JoinSecondaryTypes(ext.SecondaryTypes),
-		); err != nil {
-			return nil, fmt.Errorf("sync artist discography: insert release %s: %w", rg.ID, err)
-		}
-
-		releases = append(releases, *ext)
-	}
-
-	// Mark the artist as synced (even when it has zero release groups) so the
-	// cache TTL honours empty discographies and they are not re-fetched every
-	// cycle.
-	if err := database.TouchArtistSynced(tx, artistID, now); err != nil {
-		return nil, fmt.Errorf("sync artist discography: touch last_synced: %w", err)
-	}
-
-	if err := tx.Commit(); err != nil {
-		return nil, fmt.Errorf("sync artist discography: commit transaction: %w", err)
-	}
-
-	return releases, nil
-}
-
-// getArtistFilterOptions reads per-artist type filtering preferences.
-// Defaults to no filtering if artist_settings row doesn't exist.
-// artistID is the Navidrome artist ID (artist_settings.id), not the MusicBrainz ID.
-func getArtistFilterOptions(db *database.DB, artistID string) (FilterOptions, error) {
-	var opts FilterOptions
-	err := db.Conn().QueryRow(
-		"SELECT COALESCE(ignore_singles, 0), COALESCE(ignore_compilations, 0), COALESCE(ignore_live, 0), COALESCE(ignore_remix, 0) FROM artist_settings WHERE id = ?",
-		artistID,
-	).Scan(&opts.IgnoreSingles, &opts.IgnoreCompilations, &opts.IgnoreLive, &opts.IgnoreRemix)
-	if err == sql.ErrNoRows {
-		return opts, nil
-	}
-	if err != nil {
-		return opts, fmt.Errorf("query artist filter options: %w", err)
-	}
-	return opts, nil
-}

internal/musicbrainz/syncall.go

@@ -1,147 +0,0 @@
-package musicbrainz
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"naviwatcher/internal/database"
-)
-
-// MBIDResolver resolves a MusicBrainz artist ID for an artist name.
-// The real *MusicBrainzClient satisfies this interface.
-type MBIDResolver interface {
-	ResolveArtistMBID(ctx context.Context, name string) (string, error)
-}
-
-// ArtistDiscographySyncer syncs one artist's MusicBrainz discography into the
-// external_releases table. The real implementation (musicbrainz.SyncArtistDiscography)
-// is wrapped by discographySyncer so the concrete *MusicBrainzClient dependency
-// is injectable in tests.
-type ArtistDiscographySyncer interface {
-	SyncArtistDiscography(ctx context.Context, db *database.DB, artistID, artistMBID string, ttl time.Duration) ([]database.ExternalRelease, error)
-}
-
-// discographySyncer adapts the package-level SyncArtistDiscography function to
-// the ArtistDiscographySyncer interface, binding a concrete *MusicBrainzClient.
-type discographySyncer struct {
-	client *MusicBrainzClient
-}
-
-// NewDiscographySyncer wraps a *MusicBrainzClient as an ArtistDiscographySyncer.
-func NewDiscographySyncer(client *MusicBrainzClient) ArtistDiscographySyncer {
-	return &discographySyncer{client: client}
-}
-
-func (s *discographySyncer) SyncArtistDiscography(
-	ctx context.Context,
-	db *database.DB,
-	artistID, artistMBID string,
-	ttl time.Duration,
-) ([]database.ExternalRelease, error) {
-	return SyncArtistDiscography(ctx, s.client, db, artistID, artistMBID, ttl)
-}
-
-// AlbumSyncer copies each monitored artist's albums from Navidrome into the
-// local_albums table. The real implementation (navidrome.SyncAlbums) is wrapped
-// so the concrete *navidrome.NavidromeClient dependency is injectable in tests.
-type AlbumSyncer interface {
-	SyncAlbums(ctx context.Context, db *database.DB) error
-}
-
-// albumSyncer adapts navidrome.SyncAlbums to the AlbumSyncer interface.
-type albumSyncer struct {
-	syncAlbums func(ctx context.Context, db *database.DB) error
-}
-
-func (s *albumSyncer) SyncAlbums(ctx context.Context, db *database.DB) error {
-	return s.syncAlbums(ctx, db)
-}
-
-// NewAlbumSyncer adapts the given SyncAlbums function (typically
-// navidrome.SyncAlbums) into an AlbumSyncer for injection into SyncAll.
-func NewAlbumSyncer(syncAlbums func(ctx context.Context, db *database.DB) error) AlbumSyncer {
-	return &albumSyncer{syncAlbums: syncAlbums}
-}
-
-// SyncAll orchestrates the data pipeline for every monitored artist:
-//  1. MusicBrainz artist-ID resolution — for each artist with no cached MBID,
-//     resolve it by name and persist it on the artist_settings row. Artists that
-//     already have an MBID reuse it (no extra rate-limited MusicBrainz call).
-//  2. MusicBrainz discography sync into external_releases.
-//  3. Navidrome album sync into local_albums.
-//
-// Ordering matters: Navidrome's artist/album tables are populated by the caller
-// before SyncAll (via navidrome.SyncArtists / SyncAlbums as appropriate); here we
-// focus on the per-artist MBID + discography + album refresh. Unmonitored artists
-// are skipped.
-//
-// Resolution failures for a single artist are logged and skipped (the artist is
-// left for the next sync) rather than aborting the whole run; the error is still
-// returned so the caller can decide whether to surface it.
-func SyncAll(
-	ctx context.Context,
-	db *database.DB,
-	resolver MBIDResolver,
-	discography ArtistDiscographySyncer,
-	albums AlbumSyncer,
-	ttl time.Duration,
-) error {
-	if err := ctx.Err(); err != nil {
-		return fmt.Errorf("sync all: %w", err)
-	}
-
-	artists, err := database.GetAllArtistSettings(db)
-	if err != nil {
-		return fmt.Errorf("sync all: get artists: %w", err)
-	}
-
-	var resolutionErr error
-	for _, artist := range artists {
-		if err := ctx.Err(); err != nil {
-			return fmt.Errorf("sync all: %w", err)
-		}
-
-		// Skip unmonitored artists entirely.
-		if !artist.Monitored {
-			continue
-		}
-
-		// Ensure we have an MBID; resolve and persist if missing.
-		mbid := artist.MBID
-		if mbid == "" {
-			resolved, rerr := resolver.ResolveArtistMBID(ctx, artist.Name)
-			if rerr != nil {
-				// Skip this artist but remember the first resolution error.
-				if resolutionErr == nil {
-					resolutionErr = fmt.Errorf("resolve MBID for artist %q: %w", artist.Name, rerr)
-				}
-				continue
-			}
-			mbid = resolved
-			if perr := database.UpdateArtistSettings(db, artist.ID, map[string]interface{}{"mbid": mbid}); perr != nil {
-				if resolutionErr == nil {
-					resolutionErr = fmt.Errorf("persist MBID for artist %q: %w", artist.Name, perr)
-				}
-				continue
-			}
-		}
-
-		// Sync the artist's MusicBrainz discography.
-		if _, derr := discography.SyncArtistDiscography(ctx, db, artist.ID, mbid, ttl); derr != nil {
-			if resolutionErr == nil {
-				resolutionErr = fmt.Errorf("sync discography for artist %q: %w", artist.Name, derr)
-			}
-			continue
-		}
-	}
-
-	// Album sync operates over all monitored artists in one pass.
-	if aerr := albums.SyncAlbums(ctx, db); aerr != nil {
-		if resolutionErr == nil {
-			resolutionErr = fmt.Errorf("sync albums: %w", aerr)
-		}
-	}
-
-	return resolutionErr
-}

internal/musicbrainz/syncall_test.go

@@ -1,218 +0,0 @@
-package musicbrainz
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"testing"
-	"time"
-
-	"naviwatcher/internal/database"
-)
-
-// stubResolver is a configurable MBIDResolver for tests.
-type stubResolver struct {
-	byName map[string]string // name -> mbid
-	calls  []string          // names requested, in order
-	err    error             // optional error to return for any resolve
-}
-
-func (s *stubResolver) ResolveArtistMBID(ctx context.Context, name string) (string, error) {
-	s.calls = append(s.calls, name)
-	if s.err != nil {
-		return "", s.err
-	}
-	if mbid, ok := s.byName[name]; ok {
-		return mbid, nil
-	}
-	return "", errors.New("no match")
-}
-
-// stubDiscography records per-artist discography syncs.
-type stubDiscography struct {
-	synced []string // artistIDs
-	err    error
-}
-
-func (s *stubDiscography) SyncArtistDiscography(
-	ctx context.Context,
-	db *database.DB,
-	artistID, artistMBID string,
-	ttl time.Duration,
-) ([]database.ExternalRelease, error) {
-	if s.err != nil {
-		return nil, s.err
-	}
-	s.synced = append(s.synced, artistID)
-	return nil, nil
-}
-
-// stubAlbums records album-sync invocations.
-type stubAlbums struct {
-	called int
-	err    error
-}
-
-func (s *stubAlbums) SyncAlbums(ctx context.Context, db *database.DB) error {
-	s.called++
-	return s.err
-}
-
-func seedArtistRow(t *testing.T, db *database.DB, id, name, mbid string, monitored bool) {
-	t.Helper()
-	if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-		ID:        id,
-		Name:      name,
-		MBID:      mbid,
-		Monitored: monitored,
-	}); err != nil {
-		t.Fatalf("seed artist: %v", err)
-	}
-}
-
-func TestSyncAll_NewArtistGetsMBID(t *testing.T) {
-	db := newTestDB(t)
-	seedArtistRow(t, db, "ar1", "Radiohead", "", true)
-
-	resolver := &stubResolver{byName: map[string]string{"Radiohead": "mbid-radiohead"}}
-	disco := &stubDiscography{}
-	albs := &stubAlbums{}
-
-	err := SyncAll(context.Background(), db, resolver, disco, albs, 24*time.Hour)
-	if err != nil {
-		t.Fatalf("SyncAll() error = %v", err)
-	}
-
-	// Resolver must have been called for the new artist.
-	if len(resolver.calls) != 1 || resolver.calls[0] != "Radiohead" {
-		t.Fatalf("resolver calls = %v, want [Radiohead]", resolver.calls)
-	}
-	// MBID persisted on the row.
-	got, gerr := database.GetArtistSettings(db, "ar1")
-	if gerr != nil {
-		t.Fatalf("GetArtistSettings() error = %v", gerr)
-	}
-	if got.MBID != "mbid-radiohead" {
-		t.Errorf("persisted MBID = %q, want %q", got.MBID, "mbid-radiohead")
-	}
-	// Discography and albums synced.
-	if len(disco.synced) != 1 || disco.synced[0] != "ar1" {
-		t.Errorf("discography synced = %v, want [ar1]", disco.synced)
-	}
-	if albc := albs.called; albc != 1 {
-		t.Errorf("albums sync called = %d, want 1", albc)
-	}
-}
-
-func TestSyncAll_ExistingMBIDReused(t *testing.T) {
-	db := newTestDB(t)
-	seedArtistRow(t, db, "ar1", "Radiohead", "preset-mbid", true)
-
-	resolver := &stubResolver{byName: map[string]string{"Radiohead": "resolved-mbid"}}
-	disco := &stubDiscography{}
-	albs := &stubAlbums{}
-
-	if err := SyncAll(context.Background(), db, resolver, disco, albs, 24*time.Hour); err != nil {
-		t.Fatalf("SyncAll() error = %v", err)
-	}
-
-	// Resolver must NOT be called when MBID already present.
-	if len(resolver.calls) != 0 {
-		t.Errorf("resolver calls = %v, want none (MBID reused)", resolver.calls)
-	}
-	got, _ := database.GetArtistSettings(db, "ar1")
-	if got.MBID != "preset-mbid" {
-		t.Errorf("MBID = %q, want preserved preset-mbid", got.MBID)
-	}
-	if len(disco.synced) != 1 {
-		t.Errorf("discography synced = %v, want [ar1]", disco.synced)
-	}
-}
-
-func TestSyncAll_UnmonitoredSkipped(t *testing.T) {
-	db := newTestDB(t)
-	seedArtistRow(t, db, "ar1", "Radiohead", "", false) // unmonitored
-
-	resolver := &stubResolver{byName: map[string]string{"Radiohead": "mbid-x"}}
-	disco := &stubDiscography{}
-	albs := &stubAlbums{}
-
-	if err := SyncAll(context.Background(), db, resolver, disco, albs, 24*time.Hour); err != nil {
-		t.Fatalf("SyncAll() error = %v", err)
-	}
-
-	if len(resolver.calls) != 0 {
-		t.Errorf("resolver calls = %v, want none (unmonitored skipped)", resolver.calls)
-	}
-	if len(disco.synced) != 0 {
-		t.Errorf("discography synced = %v, want none", disco.synced)
-	}
-	// Album sync still runs (it internally skips unmonitored too), but no
-	// discography work should have happened for the skipped artist.
-}
-
-func TestSyncAll_ResolutionErrorSkipsArtist(t *testing.T) {
-	db := newTestDB(t)
-	seedArtistRow(t, db, "ar1", "Unknown", "", true)
-
-	resolver := &stubResolver{err: errors.New("mb down")}
-	disco := &stubDiscography{}
-	albs := &stubAlbums{}
-
-	err := SyncAll(context.Background(), db, resolver, disco, albs, 24*time.Hour)
-	if err == nil {
-		t.Fatal("SyncAll() expected error when resolution fails")
-	}
-	if len(disco.synced) != 0 {
-		t.Errorf("discography synced = %v, want none (resolution failed)", disco.synced)
-	}
-	// MBID must remain empty since persistence was skipped.
-	got, _ := database.GetArtistSettings(db, "ar1")
-	if got.MBID != "" {
-		t.Errorf("MBID = %q, want empty after failed resolution", got.MBID)
-	}
-}
-
-func TestSyncAll_ContextCancel(t *testing.T) {
-	db := newTestDB(t)
-	seedArtistRow(t, db, "ar1", "Radiohead", "", true)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	if err := SyncAll(ctx, db, &stubResolver{}, &stubDiscography{}, &stubAlbums{}, 24*time.Hour); err == nil {
-		t.Fatal("SyncAll() expected context error, got nil")
-	}
-}
-
-// TestDiscographySyncer_AdapterForwards verifies the adapter produced by
-// NewDiscographySyncer forwards to the real SyncArtistDiscography so that the
-// App's wiring uses the actual MusicBrainz client.
-func TestDiscographySyncer_AdapterForwards(t *testing.T) {
-	db := newTestDB(t)
-	artistID := "nav-adapter"
-	artistMBID := "bbbbbbbb-cccc-dddd-eeee-ffffffffffff"
-	seedArtistRow(t, db, artistID, "Adapter Artist", "", true)
-
-	server := newTestMBServer(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		resp := mbReleaseGroupListResponse(
-			mbReleaseGroupXML("rg1", "Adapter Album", "Album", "", artistMBID, "Adapter Artist", "2020-01-01"),
-			1,
-		)
-		w.Write([]byte(resp))
-	})
-	defer server.Close()
-
-	syncer := NewDiscographySyncer(newTestClient(server.URL))
-	releases, err := syncer.SyncArtistDiscography(context.Background(), db, artistID, artistMBID, 24*time.Hour)
-	if err != nil {
-		t.Fatalf("adapter SyncArtistDiscography() error = %v", err)
-	}
-	if len(releases) != 1 {
-		t.Fatalf("adapter expected 1 release, got %d", len(releases))
-	}
-	if releases[0].RGID != "rg1" {
-		t.Errorf("adapter release RGID = %q, want rg1", releases[0].RGID)
-	}
-}

internal/navidrome/client.go

@@ -1,131 +0,0 @@
-package navidrome
-
-import (
-	"encoding/xml"
-	"fmt"
-	"io"
-	"net/http"
-	"time"
-
-	"naviwatcher/internal/config"
-
-	"github.com/delucks/go-subsonic"
-)
-
-// ArtistInfo represents a simplified artist from the Subsonic API.
-type ArtistInfo struct {
-	ID   string
-	Name string
-}
-
-// AlbumInfo represents a simplified album from the Subsonic API.
-type AlbumInfo struct {
-	ID       string
-	Name     string
-	ArtistID string
-}
-
-// NavidromeClient wraps the go-subsonic Client with application-specific configuration.
-type NavidromeClient struct {
-	client *subsonic.Client
-}
-
-// NewClient creates a new NavidromeClient from the given configuration.
-// It authenticates with the server immediately, returning an error if auth fails.
-func NewClient(cfg config.NavidromeConfig) (*NavidromeClient, error) {
-	client := &subsonic.Client{
-		Client:     &http.Client{Timeout: 30 * time.Second},
-		BaseUrl:    cfg.URL,
-		User:       cfg.User,
-		ClientName: "naviwatcher",
-	}
-
-	if err := client.Authenticate(cfg.Password); err != nil {
-		return nil, fmt.Errorf("authenticate with navidrome: %w", err)
-	}
-
-	return &NavidromeClient{client: client}, nil
-}
-
-// NewClientUnauthenticated builds a NavidromeClient without contacting the
-// server. It is intended for dependency injection in tests (where the
-// navidromeClientFactory seam in main is overridden) and for callers that want
-// to defer or skip authentication. Production wiring should prefer NewClient.
-func NewClientUnauthenticated(cfg config.NavidromeConfig) *NavidromeClient {
-	return &NavidromeClient{client: &subsonic.Client{
-		Client:     &http.Client{Timeout: 30 * time.Second},
-		BaseUrl:    cfg.URL,
-		User:       cfg.User,
-		ClientName: "naviwatcher",
-	}}
-}
-
-// Ping checks connectivity to the Navidrome server.
-// Returns nil if the server is reachable and responds with a valid Subsonic OK status.
-func (nc *NavidromeClient) Ping() error {
-	resp, err := nc.client.Request("GET", "ping", nil)
-	if err != nil {
-		return fmt.Errorf("navidrome server is unreachable: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("navidrome server returned HTTP %d", resp.StatusCode)
-	}
-
-	// Check Subsonic application-level status: the server can return HTTP 200
-	// with status="failed" for auth errors or other issues.
-	body, err := io.ReadAll(io.LimitReader(resp.Body, 4096))
-	if err != nil {
-		return fmt.Errorf("read ping response: %w", err)
-	}
-	var parsed subsonic.Response
-	if err := xml.Unmarshal(body, &parsed); err != nil {
-		return fmt.Errorf("parse ping response XML: %w", err)
-	}
-	if parsed.Status != "ok" && parsed.Error != nil {
-		return fmt.Errorf("navidrome ping failed: code %d: %s",
-			parsed.Error.Code, parsed.Error.Message)
-	}
-	return nil
-}
-
-// GetArtists fetches all artists from the Navidrome server.
-// Returns a slice of ArtistInfo with ID and Name populated.
-func (nc *NavidromeClient) GetArtists() ([]ArtistInfo, error) {
-	artists, err := nc.client.GetArtists(nil)
-	if err != nil {
-		return nil, fmt.Errorf("get artists: %w", err)
-	}
-
-	var result []ArtistInfo
-	for _, index := range artists.Index {
-		for _, artist := range index.Artist {
-			result = append(result, ArtistInfo{
-				ID:   artist.ID,
-				Name: artist.Name,
-			})
-		}
-	}
-	return result, nil
-}
-
-// GetArtistAlbums fetches all albums for a given artist from the Navidrome server.
-// The artistID should be the Subsonic ID of the artist.
-// Returns a slice of AlbumInfo with ID, Name, and ArtistID populated.
-func (nc *NavidromeClient) GetArtistAlbums(artistID string) ([]AlbumInfo, error) {
-	artist, err := nc.client.GetArtist(artistID)
-	if err != nil {
-		return nil, fmt.Errorf("get artist %s: %w", artistID, err)
-	}
-
-	var result []AlbumInfo
-	for _, album := range artist.Album {
-		result = append(result, AlbumInfo{
-			ID:       album.ID,
-			Name:     album.Name,
-			ArtistID: album.ArtistID,
-		})
-	}
-	return result, nil
-}

internal/navidrome/client_test.go

@@ -1,372 +0,0 @@
-package navidrome
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/delucks/go-subsonic"
-	"naviwatcher/internal/config"
-)
-
-func TestNewClient_ValidConfig(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-			<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-			</subsonic-response>`))
-	}))
-	defer server.Close()
-
-	cfg := config.NavidromeConfig{
-		URL:      server.URL,
-		User:     "testuser",
-		Password: "testpass",
-	}
-
-	client, err := NewClient(cfg)
-	if err != nil {
-		t.Fatalf("NewClient() error = %v", err)
-	}
-	if client == nil {
-		t.Fatal("NewClient() returned nil client")
-	}
-	if client.client == nil {
-		t.Fatal("NewClient() returned client with nil subsonic client")
-	}
-}
-
-func TestNewClient_InvalidCredentials(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-			<subsonic-response xmlns="http://subsonic.org/restapi" status="failed" version="1.16.1">
-				<error code="40" message="Wrong username or password."/>
-			</subsonic-response>`))
-	}))
-	defer server.Close()
-
-	cfg := config.NavidromeConfig{
-		URL:      server.URL,
-		User:     "baduser",
-		Password: "badpass",
-	}
-
-	_, err := NewClient(cfg)
-	if err == nil {
-		t.Fatal("NewClient() expected error for invalid credentials, got nil")
-	}
-}
-
-func TestPing_Success(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-			<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-			</subsonic-response>`))
-	}))
-	defer server.Close()
-
-	cfg := config.NavidromeConfig{
-		URL:      server.URL,
-		User:     "testuser",
-		Password: "testpass",
-	}
-
-	client, err := NewClient(cfg)
-	if err != nil {
-		t.Fatalf("NewClient() error = %v", err)
-	}
-
-	if err := client.Ping(); err != nil {
-		t.Errorf("Ping() error = %v", err)
-	}
-}
-
-func TestPing_ServerUnreachable(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
-	serverURL := server.URL
-	server.Close()
-
-	client := &NavidromeClient{
-		client: &subsonic.Client{
-			Client:     &http.Client{},
-			BaseUrl:    serverURL,
-			User:       "testuser",
-			ClientName: "naviwatcher",
-		},
-	}
-
-	err := client.Ping()
-	if err == nil {
-		t.Error("Ping() expected error for unreachable server, got nil")
-	}
-}
-
-func TestPing_Non200Status(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusInternalServerError)
-		w.Write([]byte("Internal Server Error"))
-	}))
-	defer server.Close()
-
-	client := &NavidromeClient{
-		client: &subsonic.Client{
-			Client:     &http.Client{},
-			BaseUrl:    server.URL,
-			User:       "testuser",
-			ClientName: "naviwatcher",
-		},
-	}
-
-	err := client.Ping()
-	if err == nil {
-		t.Error("Ping() expected error for non-200 status, got nil")
-	}
-}
-
-func TestGetArtists_Success(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		if r.URL.Path == "/rest/getArtists" {
-			w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-				<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-					<artists ignoredArticles="The El La Los Las Le Les">
-						<index name="A">
-							<artist id="1" name="Artist One" albumCount="3"/>
-							<artist id="2" name="Artist Two" albumCount="1"/>
-						</index>
-						<index name="B">
-							<artist id="3" name="Band Three" albumCount="5"/>
-						</index>
-					</artists>
-				</subsonic-response>`))
-		} else {
-			w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-				<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-				</subsonic-response>`))
-		}
-	}))
-	defer server.Close()
-
-	cfg := config.NavidromeConfig{
-		URL:      server.URL,
-		User:     "testuser",
-		Password: "testpass",
-	}
-
-	nc, err := NewClient(cfg)
-	if err != nil {
-		t.Fatalf("NewClient() error = %v", err)
-	}
-
-	artists, err := nc.GetArtists()
-	if err != nil {
-		t.Fatalf("GetArtists() error = %v", err)
-	}
-
-	if len(artists) != 3 {
-		t.Fatalf("GetArtists() returned %d artists, want 3", len(artists))
-	}
-
-	expected := []ArtistInfo{
-		{ID: "1", Name: "Artist One"},
-		{ID: "2", Name: "Artist Two"},
-		{ID: "3", Name: "Band Three"},
-	}
-
-	for i, a := range artists {
-		if a.ID != expected[i].ID || a.Name != expected[i].Name {
-			t.Errorf("GetArtists()[%d] = {ID: %q, Name: %q}, want {ID: %q, Name: %q}",
-				i, a.ID, a.Name, expected[i].ID, expected[i].Name)
-		}
-	}
-}
-
-func TestGetArtists_EmptyLibrary(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-			<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-				<artists ignoredArticles="The El La Los Las Le Les">
-				</artists>
-			</subsonic-response>`))
-	}))
-	defer server.Close()
-
-	cfg := config.NavidromeConfig{
-		URL:      server.URL,
-		User:     "testuser",
-		Password: "testpass",
-	}
-
-	nc, err := NewClient(cfg)
-	if err != nil {
-		t.Fatalf("NewClient() error = %v", err)
-	}
-
-	artists, err := nc.GetArtists()
-	if err != nil {
-		t.Fatalf("GetArtists() error = %v", err)
-	}
-
-	if len(artists) != 0 {
-		t.Errorf("GetArtists() returned %d artists, want 0", len(artists))
-	}
-}
-
-func TestGetArtists_APIError(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		if r.URL.Path == "/rest/getArtists" {
-			w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-				<subsonic-response xmlns="http://subsonic.org/restapi" status="failed" version="1.16.1">
-					<error code="70" message="Requested resource not found"/>
-				</subsonic-response>`))
-			return
-		}
-		w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-			<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-			</subsonic-response>`))
-	}))
-	defer server.Close()
-
-	cfg := config.NavidromeConfig{
-		URL:      server.URL,
-		User:     "testuser",
-		Password: "testpass",
-	}
-
-	nc, err := NewClient(cfg)
-	if err != nil {
-		t.Fatalf("NewClient() error = %v", err)
-	}
-
-	_, err = nc.GetArtists()
-	if err == nil {
-		t.Fatal("GetArtists() expected error for API failure, got nil")
-	}
-}
-
-func TestGetArtistAlbums_Success(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		if r.URL.Path == "/rest/getArtist" {
-			w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-				<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-					<artist id="1" name="Artist One" albumCount="2">
-						<album id="101" name="First Album" artist="Artist One" artistId="1" songCount="10" duration="3600" created="2023-01-15T10:30:00Z"/>
-						<album id="102" name="Second Album" artist="Artist One" artistId="1" songCount="8" duration="2800" created="2024-03-20T14:00:00Z"/>
-					</artist>
-				</subsonic-response>`))
-		} else {
-			w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-				<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-				</subsonic-response>`))
-		}
-	}))
-	defer server.Close()
-
-	cfg := config.NavidromeConfig{
-		URL:      server.URL,
-		User:     "testuser",
-		Password: "testpass",
-	}
-
-	nc, err := NewClient(cfg)
-	if err != nil {
-		t.Fatalf("NewClient() error = %v", err)
-	}
-
-	albums, err := nc.GetArtistAlbums("1")
-	if err != nil {
-		t.Fatalf("GetArtistAlbums() error = %v", err)
-	}
-
-	if len(albums) != 2 {
-		t.Fatalf("GetArtistAlbums() returned %d albums, want 2", len(albums))
-	}
-
-	expected := []AlbumInfo{
-		{ID: "101", Name: "First Album", ArtistID: "1"},
-		{ID: "102", Name: "Second Album", ArtistID: "1"},
-	}
-
-	for i, a := range albums {
-		if a.ID != expected[i].ID || a.Name != expected[i].Name || a.ArtistID != expected[i].ArtistID {
-			t.Errorf("GetArtistAlbums()[%d] = {ID: %q, Name: %q, ArtistID: %q}, want {ID: %q, Name: %q, ArtistID: %q}",
-				i, a.ID, a.Name, a.ArtistID, expected[i].ID, expected[i].Name, expected[i].ArtistID)
-		}
-	}
-}
-
-func TestGetArtistAlbums_NoAlbums(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		if r.URL.Path == "/rest/getArtist" {
-			w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-				<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-					<artist id="5" name="Lonely Artist" albumCount="0">
-					</artist>
-				</subsonic-response>`))
-		} else {
-			w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-				<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-				</subsonic-response>`))
-		}
-	}))
-	defer server.Close()
-
-	cfg := config.NavidromeConfig{
-		URL:      server.URL,
-		User:     "testuser",
-		Password: "testpass",
-	}
-
-	nc, err := NewClient(cfg)
-	if err != nil {
-		t.Fatalf("NewClient() error = %v", err)
-	}
-
-	albums, err := nc.GetArtistAlbums("5")
-	if err != nil {
-		t.Fatalf("GetArtistAlbums() error = %v", err)
-	}
-
-	if len(albums) != 0 {
-		t.Errorf("GetArtistAlbums() returned %d albums, want 0", len(albums))
-	}
-}
-
-func TestGetArtistAlbums_APIError(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		if r.URL.Path == "/rest/getArtist" {
-			w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-				<subsonic-response xmlns="http://subsonic.org/restapi" status="failed" version="1.16.1">
-					<error code="70" message="Requested resource not found"/>
-				</subsonic-response>`))
-			return
-		}
-		w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-			<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">
-			</subsonic-response>`))
-	}))
-	defer server.Close()
-
-	cfg := config.NavidromeConfig{
-		URL:      server.URL,
-		User:     "testuser",
-		Password: "testpass",
-	}
-
-	nc, err := NewClient(cfg)
-	if err != nil {
-		t.Fatalf("NewClient() error = %v", err)
-	}
-
-	_, err = nc.GetArtistAlbums("999")
-	if err == nil {
-		t.Fatal("GetArtistAlbums() expected error for API failure, got nil")
-	}
-}

internal/navidrome/sync.go

@@ -1,130 +0,0 @@
-package navidrome
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"log"
-
-	"naviwatcher/internal/database"
-)
-
-// SyncAlbums fetches all albums from Navidrome for each monitored artist and
-// stores them in the local_albums table. For each artist, existing local albums
-// are deleted before inserting the fresh set, so the table always reflects the
-// current Navidrome state. Unmonitored artists are skipped.
-// Context cancellation is checked before each artist's album fetch.
-func SyncAlbums(ctx context.Context, client *NavidromeClient, db *database.DB) error {
-	if err := ctx.Err(); err != nil {
-		return fmt.Errorf("sync albums: %w", err)
-	}
-
-	// Get all artists from the local database.
-	artists, err := database.GetAllArtistSettings(db)
-	if err != nil {
-		return fmt.Errorf("sync albums: get artists: %w", err)
-	}
-
-	for _, artist := range artists {
-		if err := ctx.Err(); err != nil {
-			return fmt.Errorf("sync albums: %w", err)
-		}
-
-		// Skip unmonitored artists.
-		if !artist.Monitored {
-			continue
-		}
-
-		albums, err := client.GetArtistAlbums(artist.ID)
-		if err != nil {
-			// A transient failure for one artist must not abort the whole pull
-			// and take down the daemon; log it and continue with the remaining
-			// artists, matching the resilience of SyncAll/ScanAll.
-			log.Printf("sync albums: skip artist %s: %v", artist.ID, err)
-			continue
-		}
-
-		// Delete existing albums for this artist and insert fresh set within
-		// a transaction to prevent partial sync state on failure.
-		tx, err := db.Begin()
-		if err != nil {
-			return fmt.Errorf("sync albums: begin transaction for artist %s: %w", artist.ID, err)
-		}
-		if err := database.DeleteLocalAlbumsByArtistTx(tx, artist.ID); err != nil {
-			tx.Rollback()
-			return fmt.Errorf("sync albums: delete existing for artist %s: %w", artist.ID, err)
-		}
-
-		for _, album := range albums {
-			if err := ctx.Err(); err != nil {
-				tx.Rollback()
-				return fmt.Errorf("sync albums: %w", err)
-			}
-
-			localAlbum := &database.LocalAlbum{
-				ID:       album.ID,
-				ArtistID: artist.ID,
-				Title:    album.Name,
-			}
-			if err := database.SaveLocalAlbumTx(tx, localAlbum); err != nil {
-				tx.Rollback()
-				return fmt.Errorf("sync albums: save album %s: %w", album.ID, err)
-			}
-		}
-		if err := tx.Commit(); err != nil {
-			return fmt.Errorf("sync albums: commit for artist %s: %w", artist.ID, err)
-		}
-	}
-
-	return nil
-}
-
-// SyncArtists fetches all artists from Navidrome and upserts them into the
-// local artist_settings table. New artists are inserted with monitored=true.
-// Existing artists have their name refreshed but their monitored/ignore
-// settings are preserved.
-// Context cancellation is checked before the API call and between individual
-// artist upserts.
-func SyncArtists(ctx context.Context, client *NavidromeClient, db *database.DB) error {
-	// Check context before making the API call.
-	if err := ctx.Err(); err != nil {
-		return fmt.Errorf("sync artists: %w", err)
-	}
-
-	artists, err := client.GetArtists()
-	if err != nil {
-		return fmt.Errorf("sync artists: %w", err)
-	}
-
-	for _, artist := range artists {
-		// Check context cancellation between each upsert to allow
-		// graceful interruption on large libraries.
-		if err := ctx.Err(); err != nil {
-			return fmt.Errorf("sync artists: %w", err)
-		}
-
-		// Preserve existing user settings (monitored, ignore_singles,
-		// ignore_compilations) if the row already exists.
-		settings := &database.ArtistSettings{
-			ID:        artist.ID,
-			Name:      artist.Name,
-			Monitored: true,
-		}
-		existing, err := database.GetArtistSettings(db, artist.ID)
-		if err == nil {
-			settings.MBID = existing.MBID
-			settings.Monitored = existing.Monitored
-			settings.IgnoreSingles = existing.IgnoreSingles
-			settings.IgnoreCompilations = existing.IgnoreCompilations
-			settings.LastSynced = existing.LastSynced
-		} else if !errors.Is(err, database.ErrArtistNotFound) {
-			return fmt.Errorf("sync artists: get settings for artist %s: %w", artist.ID, err)
-		}
-
-		if err := database.SaveArtistSettings(db, settings); err != nil {
-			return fmt.Errorf("sync artists: save artist %s: %w", artist.ID, err)
-		}
-	}
-
-	return nil
-}

internal/navidrome/sync_test.go

@@ -1,457 +0,0 @@
-package navidrome
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"naviwatcher/internal/config"
-	"naviwatcher/internal/database"
-)
-
-// newTestServerAndClient creates a mock Subsonic server and a NavidromeClient
-// pointing at it. The handler receives the raw HTTP requests so tests can
-// inspect them if needed.
-func newTestServerAndClient(handler http.HandlerFunc) (*httptest.Server, *NavidromeClient) {
-	server := httptest.NewServer(handler)
-	cfg := config.NavidromeConfig{
-		URL:      server.URL,
-		User:     "testuser",
-		Password: "testpass",
-	}
-	nc, err := NewClient(cfg)
-	if err != nil {
-		server.Close()
-		panic(fmt.Sprintf("NewClient() in test setup failed: %v", err))
-	}
-	return server, nc
-}
-
-// subsonicOKResponse returns a minimal valid Subsonic XML response.
-func subsonicOKResponse(body string) string {
-	return `<?xml version="1.0" encoding="UTF-8"?>
-<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1">` +
-		body + `</subsonic-response>`
-}
-
-func TestSyncArtists_EmptyLibrary(t *testing.T) {
-	server, nc := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		if r.URL.Path == "/rest/getArtists" {
-			w.Write([]byte(subsonicOKResponse(`<artists ignoredArticles="The"></artists>`)))
-			return
-		}
-		w.Write([]byte(subsonicOKResponse("")))
-	})
-	defer server.Close()
-
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	defer db.Close()
-
-	ctx := context.Background()
-	if err := SyncArtists(ctx, nc, db); err != nil {
-		t.Fatalf("SyncArtists() error: %v", err)
-	}
-
-	// Verify no artists in DB.
-	artists, err := database.GetAllArtistSettings(db)
-	if err != nil {
-		t.Fatalf("GetAllArtistSettings() error: %v", err)
-	}
-	if len(artists) != 0 {
-		t.Errorf("expected 0 artists in DB, got %d", len(artists))
-	}
-}
-
-func TestSyncArtists_MultipleArtists(t *testing.T) {
-	server, nc := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		if r.URL.Path == "/rest/getArtists" {
-			w.Write([]byte(subsonicOKResponse(`
-				<artists ignoredArticles="The">
-					<index name="A">
-						<artist id="1" name="Artist One" albumCount="3"/>
-						<artist id="2" name="Artist Two" albumCount="1"/>
-					</index>
-					<index name="B">
-						<artist id="3" name="Band Three" albumCount="5"/>
-					</index>
-				</artists>`)))
-			return
-		}
-		w.Write([]byte(subsonicOKResponse("")))
-	})
-	defer server.Close()
-
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	defer db.Close()
-
-	ctx := context.Background()
-	if err := SyncArtists(ctx, nc, db); err != nil {
-		t.Fatalf("SyncArtists() error: %v", err)
-	}
-
-	artists, err := database.GetAllArtistSettings(db)
-	if err != nil {
-		t.Fatalf("GetAllArtistSettings() error: %v", err)
-	}
-	if len(artists) != 3 {
-		t.Fatalf("expected 3 artists in DB, got %d", len(artists))
-	}
-
-	// Build a map for order-independent comparison.
-	byID := make(map[string]database.ArtistSettings)
-	for _, a := range artists {
-		byID[a.ID] = a
-	}
-
-	expected := map[string]database.ArtistSettings{
-		"1": {ID: "1", Name: "Artist One", Monitored: true},
-		"2": {ID: "2", Name: "Artist Two", Monitored: true},
-		"3": {ID: "3", Name: "Band Three", Monitored: true},
-	}
-
-	for id, exp := range expected {
-		got, ok := byID[id]
-		if !ok {
-			t.Errorf("expected artist %s in DB", id)
-			continue
-		}
-		if got.Name != exp.Name {
-			t.Errorf("artist %s: expected Name %q, got %q", id, exp.Name, got.Name)
-		}
-		if !got.Monitored {
-			t.Errorf("artist %s: expected Monitored=true, got false", id)
-		}
-	}
-}
-
-func TestSyncArtists_Idempotency(t *testing.T) {
-	server, nc := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		if r.URL.Path == "/rest/getArtists" {
-			w.Write([]byte(subsonicOKResponse(`
-				<artists ignoredArticles="The">
-					<index name="A">
-						<artist id="1" name="Artist One" albumCount="2"/>
-					</index>
-				</artists>`)))
-			return
-		}
-		w.Write([]byte(subsonicOKResponse("")))
-	})
-	defer server.Close()
-
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	defer db.Close()
-
-	ctx := context.Background()
-
-	// First sync.
-	if err := SyncArtists(ctx, nc, db); err != nil {
-		t.Fatalf("first SyncArtists() error: %v", err)
-	}
-
-	artists1, err := database.GetAllArtistSettings(db)
-	if err != nil {
-		t.Fatalf("GetAllArtistSettings() after first sync error: %v", err)
-	}
-	if len(artists1) != 1 {
-		t.Fatalf("expected 1 artist after first sync, got %d", len(artists1))
-	}
-
-	// Manually change monitored to false to verify it is preserved across syncs.
-	if err := database.UpdateArtistSettings(db, "1", map[string]interface{}{"monitored": false}); err != nil {
-		t.Fatalf("UpdateArtistSettings() error: %v", err)
-	}
-
-	// Second sync — should not duplicate, and should preserve monitored=false.
-	if err := SyncArtists(ctx, nc, db); err != nil {
-		t.Fatalf("second SyncArtists() error: %v", err)
-	}
-
-	artists2, err := database.GetAllArtistSettings(db)
-	if err != nil {
-		t.Fatalf("GetAllArtistSettings() after second sync error: %v", err)
-	}
-	if len(artists2) != 1 {
-		t.Fatalf("expected 1 artist after second sync (no duplicates), got %d", len(artists2))
-	}
-
-	// Verify the artist was updated (monitored setting was preserved (not reset to true)).
-	got, err := database.GetArtistSettings(db, "1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings() error: %v", err)
-	}
-	if got.Monitored {
-		t.Error("expected Monitored=false to be preserved after re-sync, got true")
-	}
-	if got.Name != "Artist One" {
-		t.Errorf("expected Name 'Artist One', got %q", got.Name)
-	}
-}
-
-func TestSyncAlbums_SingleArtist(t *testing.T) {
-	server, nc := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		switch r.URL.Path {
-		case "/rest/getArtists":
-			// No artists returned — we pre-seed the DB below.
-			w.Write([]byte(subsonicOKResponse(`<artists ignoredArticles="The"></artists>`)))
-		case "/rest/getArtist":
-			w.Write([]byte(subsonicOKResponse(`
-				<artist id="1" name="Artist One" albumCount="2">
-					<album id="101" name="First Album" artist="Artist One" artistId="1" songCount="10" duration="3600" created="2023-01-15T10:30:00Z"/>
-					<album id="102" name="Second Album" artist="Artist One" artistId="1" songCount="8" duration="2800" created="2024-03-20T14:00:00Z"/>
-				</artist>`)))
-		default:
-			w.Write([]byte(subsonicOKResponse("")))
-		}
-	})
-	defer server.Close()
-
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Pre-seed a monitored artist.
-	if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-		ID:        "1",
-		Name:      "Artist One",
-		Monitored: true,
-	}); err != nil {
-		t.Fatalf("SaveArtistSettings() error: %v", err)
-	}
-
-	ctx := context.Background()
-	if err := SyncAlbums(ctx, nc, db); err != nil {
-		t.Fatalf("SyncAlbums() error: %v", err)
-	}
-
-	albums, err := database.GetLocalAlbumsByArtist(db, "1")
-	if err != nil {
-		t.Fatalf("GetLocalAlbumsByArtist() error: %v", err)
-	}
-	if len(albums) != 2 {
-		t.Fatalf("expected 2 albums, got %d", len(albums))
-	}
-
-	byID := make(map[string]database.LocalAlbum)
-	for _, a := range albums {
-		byID[a.ID] = a
-	}
-
-	exp1 := database.LocalAlbum{ID: "101", ArtistID: "1", Title: "First Album"}
-	if got, ok := byID["101"]; !ok {
-		t.Error("expected album 101 in DB")
-	} else if got != exp1 {
-		t.Errorf("album 101 = %+v, want %+v", got, exp1)
-	}
-
-	exp2 := database.LocalAlbum{ID: "102", ArtistID: "1", Title: "Second Album"}
-	if got, ok := byID["102"]; !ok {
-		t.Error("expected album 102 in DB")
-	} else if got != exp2 {
-		t.Errorf("album 102 = %+v, want %+v", got, exp2)
-	}
-}
-
-func TestSyncAlbums_SkipsUnmonitored(t *testing.T) {
-	server, nc := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		switch r.URL.Path {
-		case "/rest/getArtists":
-			w.Write([]byte(subsonicOKResponse(`<artists ignoredArticles="The"></artists>`)))
-		case "/rest/getArtist":
-			// This should NOT be called for unmonitored artist.
-			t.Error("GetArtist should not be called for unmonitored artist")
-			w.Write([]byte(subsonicOKResponse(`<artist id="2" name="Unmonitored" albumCount="0"></artist>`)))
-		default:
-			w.Write([]byte(subsonicOKResponse("")))
-		}
-	})
-	defer server.Close()
-
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Pre-seed an unmonitored artist.
-	if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-		ID:        "2",
-		Name:      "Unmonitored",
-		Monitored: false,
-	}); err != nil {
-		t.Fatalf("SaveArtistSettings() error: %v", err)
-	}
-
-	ctx := context.Background()
-	if err := SyncAlbums(ctx, nc, db); err != nil {
-		t.Fatalf("SyncAlbums() error: %v", err)
-	}
-
-	// Verify no albums were stored.
-	allAlbums, err := database.GetAllLocalAlbums(db)
-	if err != nil {
-		t.Fatalf("GetAllLocalAlbums() error: %v", err)
-	}
-	if len(allAlbums) != 0 {
-		t.Errorf("expected 0 albums for unmonitored artist, got %d", len(allAlbums))
-	}
-}
-
-func TestSyncAlbums_APIErrorMidSync(t *testing.T) {
-	callCount := 0
-	server, nc := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		switch r.URL.Path {
-		case "/rest/getArtists":
-			w.Write([]byte(subsonicOKResponse(`<artists ignoredArticles="The"></artists>`)))
-		case "/rest/getArtist":
-			callCount++
-			if callCount == 2 {
-				// Fail on the second artist.
-				w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
-					<subsonic-response xmlns="http://subsonic.org/restapi" status="failed" version="1.16.1">
-						<error code="70" message="Requested resource not found"/>
-					</subsonic-response>`))
-				return
-			}
-			w.Write([]byte(subsonicOKResponse(`
-				<artist id="` + r.URL.Query().Get("id") + `" name="Artist" albumCount="1">
-					<album id="101" name="Album One" artist="Artist" artistId="1" songCount="5" duration="1800" created="2023-01-01T00:00:00Z"/>
-				</artist>`)))
-		default:
-			w.Write([]byte(subsonicOKResponse("")))
-		}
-	})
-	defer server.Close()
-
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Pre-seed two monitored artists.
-	for _, id := range []string{"1", "2"} {
-		if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-			ID:        id,
-			Name:      "Artist " + id,
-			Monitored: true,
-		}); err != nil {
-			t.Fatalf("SaveArtistSettings() error: %v", err)
-		}
-	}
-
-	ctx := context.Background()
-	// A transient failure for one artist must not abort the whole pull: the
-	// failing artist is skipped (and logged) while the others succeed.
-	err = SyncAlbums(ctx, nc, db)
-	if err != nil {
-		t.Fatalf("SyncAlbums() expected no fatal error on per-artist API failure, got %v", err)
-	}
-
-	// The first artist's albums should have been stored despite the second one
-	// failing.
-	albums1, err := database.GetLocalAlbumsByArtist(db, "1")
-	if err != nil {
-		t.Fatalf("GetLocalAlbumsByArtist(1) error: %v", err)
-	}
-	if len(albums1) != 1 {
-		t.Errorf("expected 1 album for artist 1 (synced before skip), got %d", len(albums1))
-	}
-
-	// The failing artist should have no local albums stored.
-	albums2, err := database.GetLocalAlbumsByArtist(db, "2")
-	if err != nil {
-		t.Fatalf("GetLocalAlbumsByArtist(2) error: %v", err)
-	}
-	if len(albums2) != 0 {
-		t.Errorf("expected 0 albums for artist 2 (skipped on error), got %d", len(albums2))
-	}
-}
-
-func TestSyncArtists_ContextCancellation(t *testing.T) {
-	server, nc := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		if r.URL.Path == "/rest/getArtists" {
-			w.Write([]byte(subsonicOKResponse(`
-				<artists ignoredArticles="The">
-					<index name="A">
-						<artist id="1" name="Artist One" albumCount="1"/>
-					</index>
-				</artists>`)))
-			return
-		}
-		w.Write([]byte(subsonicOKResponse("")))
-	})
-	defer server.Close()
-
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Create a context that is already cancelled.
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	err = SyncArtists(ctx, nc, db)
-	if err == nil {
-		t.Fatal("SyncArtists() expected error for cancelled context, got nil")
-	}
-}
-
-func TestSyncAlbums_ContextCancellation(t *testing.T) {
-	server, nc := newTestServerAndClient(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/xml")
-		switch r.URL.Path {
-		case "/rest/getArtists":
-			w.Write([]byte(subsonicOKResponse(`<artists ignoredArticles="The"></artists>`)))
-		default:
-			w.Write([]byte(subsonicOKResponse("")))
-		}
-	})
-	defer server.Close()
-
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	defer db.Close()
-
-	// Pre-seed a monitored artist so SyncAlbums has work to do.
-	if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-		ID:        "1",
-		Name:      "Artist One",
-		Monitored: true,
-	}); err != nil {
-		t.Fatalf("SaveArtistSettings() error: %v", err)
-	}
-
-	// Create a context that is already cancelled.
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	err = SyncAlbums(ctx, nc, db)
-	if err == nil {
-		t.Fatal("SyncAlbums() expected error for cancelled context, got nil")
-	}
-}

internal/normalize/normalize.go

@@ -1,120 +0,0 @@
-// Package normalize provides string normalization helpers used for
-// fuzzy matching across NaviWatcher (artist names, album titles, etc.).
-//
-// It is the single shared home for normalization logic; previously this
-// lived inside the musicbrainz package but is needed by the scanner engine
-// and any other consumer that compares strings.
-package normalize
-
-import (
-	"regexp"
-	"strings"
-	"unicode"
-)
-
-// Precompiled regexes — compiled once at package init.
-var (
-	bracketRe = regexp.MustCompile(`\[[^\]]*\]`)
-	parenRe   = regexp.MustCompile(`\([^)]*\)`)
-	yearRe    = regexp.MustCompile(`\b[0-9]{4}\b`)
-	// keywordRe strips common reissue/edition keywords that appear WITHOUT
-	// brackets or parentheses (e.g. "The Wall 2011 Remaster", "Album 2020
-	// Remastered", "X Deluxe"). MusicBrainz release-group titles frequently
-	// carry these as free-standing words; they must be removed so a remaster
-	// still matches the plain local title above the fuzzy threshold.
-	keywordRe = regexp.MustCompile(`(?i)\b(remaster|remastered|remix|deluxe|expanded|edition|reissue|anniversary|bonus)\b`)
-	spaceRe   = regexp.MustCompile(`\s+`)
-	// bareYearRe matches a title that is *only* a single year (with optional
-	// surrounding whitespace), e.g. "1989" or "2112". Used to decide whether a
-	// title that collapses entirely to a year should keep it (so it matches
-	// itself) or be treated as a distinct reissue that must collapse to empty.
-	bareYearRe = regexp.MustCompile(`^\s*[0-9]{4}\s*$`)
-)
-
-// NormalizeString normalizes a string for fuzzy matching by:
-//   - Converting to lowercase
-//   - Removing special characters (keeping only letters, digits, and spaces)
-//   - Removing years (4-digit numbers that look like years)
-//   - Removing bracketed keywords (e.g., [Deluxe], [Remastered])
-//   - Collapsing multiple spaces into one
-//   - Trimming leading/trailing whitespace
-func NormalizeString(s string) string {
-	// Capture the original input; used after stripping to tell a bare year
-	// title apart from a title that merely collapses to a year.
-	original := s
-
-	// Convert to lowercase
-	s = strings.ToLower(s)
-
-	// Remove bracketed content first (e.g., [Deluxe Edition], [Remastered 2020])
-	s = bracketRe.ReplaceAllString(s, "")
-
-	// Remove parenthesized content (e.g., (Deluxe), (Remastered))
-	s = parenRe.ReplaceAllString(s, "")
-
-	// Remove standalone reissue/edition keywords (e.g. "2011 Remaster",
-	// "2020 Remastered", "Deluxe"). These appear without brackets/parens
-	// in many MusicBrainz titles and must be stripped so a remaster still
-	// matches the plain local title above the fuzzy threshold.
-	s = keywordRe.ReplaceAllString(s, "")
-
-	// Remove years (any 4-digit number). If stripping the year
-	// empties the entire string, decide what to keep:
-	//   - A bare year title (e.g. "1989", "2112") has no other words, so keep
-	//     the year so it can still match itself (the user owns that album).
-	//   - A title that had OTHER words alongside the year (e.g. "1989 (Deluxe)")
-	//     collapses to empty on purpose: it is a distinct release group that
-	//     must NOT be considered already-present just because the user owns the
-	//     standard "1989". Collapsing to empty makes it score 0.0 against a
-	//     plain "1989", correctly reporting the reissue as missing. The check
-	//     is against the original (brackets intact) so a title like "1989
-	//     [2020]" is correctly NOT treated as a bare year.
-	stripped := yearRe.ReplaceAllString(s, "")
-	if strings.TrimSpace(stripped) == "" {
-		if bareYearRe.MatchString(strings.TrimSpace(original)) {
-			s = strings.TrimSpace(s)
-		} else {
-			s = ""
-		}
-	} else {
-		s = stripped
-	}
-
-	// Replace common separators with spaces before stripping other special chars
-	s = strings.ReplaceAll(s, "-", " ")
-	s = strings.ReplaceAll(s, "_", " ")
-
-	// Keep only letters, digits, and spaces
-	var b strings.Builder
-	for _, r := range s {
-		if unicode.IsLetter(r) || unicode.IsDigit(r) || unicode.IsSpace(r) {
-			b.WriteRune(r)
-		}
-	}
-	s = b.String()
-
-	// Collapse multiple spaces
-	s = spaceRe.ReplaceAllString(s, " ")
-
-	// Trim
-	s = strings.TrimSpace(s)
-
-	return s
-}
-
-// NormalizeArtistName normalizes an artist name for comparison.
-// It applies NormalizeString and additionally handles common prefixes.
-func NormalizeArtistName(name string) string {
-	name = NormalizeString(name)
-
-	// Remove common leading articles for better matching
-	prefixes := []string{"the ", "a ", "an "}
-	for _, prefix := range prefixes {
-		if strings.HasPrefix(name, prefix) {
-			name = strings.TrimPrefix(name, prefix)
-			break
-		}
-	}
-
-	return strings.TrimSpace(name)
-}

internal/normalize/normalize_test.go

@@ -1,104 +0,0 @@
-package normalize
-
-import "testing"
-
-func TestNormalizeString_Basic(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected string
-	}{
-		// Lowercase conversion
-		{"DARK SIDE OF THE MOON", "dark side of the moon"},
-		// Special character removal
-		{"Dark Side of the Moon!", "dark side of the moon"},
-		{"Dark-Side-of-the-Moon", "dark side of the moon"},
-		{"Dark_Side_of_the_Moon", "dark side of the moon"},
-		// Bracket removal
-		{"Dark Side of the Moon [Deluxe Edition]", "dark side of the moon"},
-		{"Dark Side of the Moon [Remastered 2020]", "dark side of the moon"},
-		{"Album [2023 Remix]", "album"},
-		// Parenthesis removal
-		{"Dark Side of the Moon (Deluxe)", "dark side of the moon"},
-		{"Album (Remastered)", "album"},
-		// Year removal
-		{"Dark Side of the Moon 1973", "dark side of the moon"},
-		// Standalone reissue keywords (no brackets/parens) are stripped
-		{"Album 2020 Remastered", "album"},
-		{"The Wall 2011 Remaster", "the wall"},
-		{"X Deluxe", "x"},
-		{"Y Expanded Edition", "y"},
-		{"Z Remix", "z"},
-		// Space collapsing
-		{"Dark   Side   of   the   Moon", "dark side of the moon"},
-		// Trim
-		{"  Dark Side of the Moon  ", "dark side of the moon"},
-		// Combined
-		{"The Dark Side of the Moon [2011 Remaster] (Deluxe Edition)", "the dark side of the moon"},
-		// Empty
-		{"", ""},
-		// Only special chars
-		{"!@#$%^&*()", ""},
-		// Digits that are not years should stay
-		{"30 Seconds to Mars", "30 seconds to mars"},
-		{"1941 - The Greatest Hits", "the greatest hits"},
-		// Year-only title is preserved (not collapsed to empty) so it can still match
-		{"1989", "1989"},
-		{"2112", "2112"},
-		// A year-plus-suffix title collapses to empty: it is a distinct release
-		// group (e.g. "1989 (Deluxe)") and must NOT match a bare "1989".
-		{"1989 (Deluxe)", ""},
-		{"1989 [Deluxe Edition]", ""},
-		{"2112 (Remastered)", ""},
-		// Regression: a year with a bracketed/suffixed year must NOT collapse to
-		// the bare year (it falsely matched "1989" before). It collapses to empty.
-		{"1989 [2020]", ""},
-		{"1989 2020", ""},
-		// Both tokens are years → both stripped → empty (no album words remain).
-		{"3000 2000", ""},
-		{"1989 RMX", "rmx"},
-		// Regression: year regex must cover ALL 4-digit years, not just 1000-2999.
-		// A reissue of a year-titled album outside that range must still collapse
-		// to empty so it is correctly reported as missing and does NOT falsely
-		// match a bare year-titled local album.
-		{"3000", "3000"},
-		{"3000 (Remastered)", ""},
-		{"3010 [Deluxe Edition]", ""},
-		{"4000 (Remastered)", ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.input, func(t *testing.T) {
-			got := NormalizeString(tt.input)
-			if got != tt.expected {
-				t.Errorf("NormalizeString(%q) = %q, want %q", tt.input, got, tt.expected)
-			}
-		})
-	}
-}
-
-func TestNormalizeArtistName(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected string
-	}{
-		{"Pink Floyd", "pink floyd"},
-		{"The Beatles", "beatles"},
-		{"A Perfect Circle", "perfect circle"},
-		{"An Orchestra", "orchestra"},
-		{"  The  Who  ", "who"},
-		{"THE WHO", "who"},
-		// No stripping needed
-		{"Radiohead", "radiohead"},
-		// Already stripped
-		{"Beatles", "beatles"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.input, func(t *testing.T) {
-			got := NormalizeArtistName(tt.input)
-			if got != tt.expected {
-				t.Errorf("NormalizeArtistName(%q) = %q, want %q", tt.input, got, tt.expected)
-			}
-		})
-	}
-}

internal/notifier/cron_schedule.go

@@ -1,31 +0,0 @@
-package notifier
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/robfig/cron/v3"
-)
-
-// CronSchedule wraps a robfig/cron schedule to satisfy the notifier.Schedule
-// interface used by StartScheduler. The spec follows the standard 5-field cron
-// syntax (e.g. "0 9 * * *" for daily at 09:00 in the process local time).
-type CronSchedule struct {
-	spec string
-	c    cron.Schedule
-}
-
-// NewCronSchedule parses a cron spec and returns a Schedule. An error is
-// returned if the spec is not a valid cron expression.
-func NewCronSchedule(spec string) (*CronSchedule, error) {
-	c, err := cron.ParseStandard(spec)
-	if err != nil {
-		return nil, fmt.Errorf("parse cron schedule %q: %w", spec, err)
-	}
-	return &CronSchedule{spec: spec, c: c}, nil
-}
-
-// Next returns the next time the schedule fires after t.
-func (s *CronSchedule) Next(t time.Time) time.Time {
-	return s.c.Next(t)
-}

internal/notifier/digest.go

@@ -1,71 +0,0 @@
-package notifier
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	"naviwatcher/internal/scanner"
-)
-
-// FormatDigest renders newly-found missing releases into a human-readable
-// Telegram message grouped by artist, with per-artist counts and a link to
-// the Web UI dashboard. It is deterministic: artists are sorted by label and
-// releases within an artist are sorted by title.
-//
-// artistNames maps an ArtistID to its human-readable display name. Names are
-// optional: if an ID is absent from the map (or the map itself is nil), the
-// raw ArtistID is used as the label so the digest remains informative.
-func FormatDigest(missing []scanner.MissingRelease, uiBaseURL string, artistNames map[string]string) string {
-	if len(missing) == 0 {
-		return "NaviWatcher: no new missing releases found."
-	}
-
-	type entry struct {
-		title string
-	}
-	byArtist := make(map[string][]entry)
-	order := make([]string, 0)
-	for _, r := range missing {
-		if _, ok := byArtist[r.ArtistID]; !ok {
-			order = append(order, r.ArtistID)
-		}
-		byArtist[r.ArtistID] = append(byArtist[r.ArtistID], entry{title: r.Title})
-	}
-	// Stable ordering by display label (name if known, else ID).
-	sort.Slice(order, func(i, j int) bool {
-		return artistLabel(order[i], artistNames) < artistLabel(order[j], artistNames)
-	})
-
-	var b strings.Builder
-	fmt.Fprintf(&b, "NaviWatcher: %d new missing release(s) found:\n\n", len(missing))
-	for _, artistID := range order {
-		entries := byArtist[artistID]
-		titles := make([]string, 0, len(entries))
-		for _, e := range entries {
-			titles = append(titles, e.title)
-		}
-		sort.Strings(titles)
-		fmt.Fprintf(&b, "%s (%d):\n", artistLabel(artistID, artistNames), len(titles))
-		for _, t := range titles {
-			fmt.Fprintf(&b, "  - %s\n", t)
-		}
-		b.WriteString("\n")
-	}
-	if uiBaseURL != "" {
-		fmt.Fprintf(&b, "View details: %s\n", strings.TrimRight(uiBaseURL, "/"))
-	}
-	return strings.TrimRight(b.String(), "\n")
-}
-
-// artistLabel returns the human-readable display name for an artist ID when
-// available, otherwise the raw ID. A non-empty name takes precedence so
-// operators see recognizable artist names rather than opaque internal IDs.
-func artistLabel(artistID string, names map[string]string) string {
-	if names != nil {
-		if name, ok := names[artistID]; ok && name != "" {
-			return name
-		}
-	}
-	return artistID
-}

internal/notifier/notifier_test.go

@@ -1,165 +0,0 @@
-package notifier
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"naviwatcher/internal/scanner"
-)
-
-type stubSender struct {
-	sent    []string
-	failErr error
-}
-
-func (s *stubSender) Send(ctx context.Context, message string) error {
-	if s.failErr != nil {
-		return s.failErr
-	}
-	s.sent = append(s.sent, message)
-	return nil
-}
-
-func TestFormatDigest_Empty(t *testing.T) {
-	got := FormatDigest(nil, "http://ui", nil)
-	if got != "NaviWatcher: no new missing releases found." {
-		t.Fatalf("unexpected empty digest: %q", got)
-	}
-}
-
-func TestFormatDigest_GroupsByArtistAndCounts(t *testing.T) {
-	missing := []scanner.MissingRelease{
-		{ArtistID: "art-b", Title: "Zebra", RGID: "r3"},
-		{ArtistID: "art-a", Title: "Alpha", RGID: "r1"},
-		{ArtistID: "art-a", Title: "Beta", RGID: "r2"},
-	}
-	got := FormatDigest(missing, "http://localhost:8080/", nil)
-	if !strings.Contains(got, "art-a (2):") {
-		t.Errorf("expected art-a with count 2, got:\n%s", got)
-	}
-	if !strings.Contains(got, "art-b (1):") {
-		t.Errorf("expected art-b with count 1, got:\n%s", got)
-	}
-	// art-a should be alphabetically before art-b.
-	if strings.Index(got, "art-a") > strings.Index(got, "art-b") {
-		t.Errorf("artists not sorted: got:\n%s", got)
-	}
-	// Releases within artist sorted: Alpha before Beta.
-	aIdx := strings.Index(got, "Alpha")
-	bIdx := strings.Index(got, "Beta")
-	if aIdx > bIdx {
-		t.Errorf("titles not sorted: got:\n%s", got)
-	}
-	if !strings.Contains(got, "View details: http://localhost:8080") {
-		t.Errorf("expected UI link, got:\n%s", got)
-	}
-}
-
-func TestFormatDigest_UsesArtistNameWhenProvided(t *testing.T) {
-	missing := []scanner.MissingRelease{
-		{ArtistID: "art-2", Title: "Zebra", RGID: "r3"},
-		{ArtistID: "art-1", Title: "Alpha", RGID: "r1"},
-		{ArtistID: "art-1", Title: "Beta", RGID: "r2"},
-	}
-	names := map[string]string{"art-1": "Alpha Artist", "art-2": "Zebra Artist"}
-	got := FormatDigest(missing, "", names)
-	// Display names are used as labels and sorted alphabetically by name.
-	if !strings.Contains(got, "Alpha Artist (2):") {
-		t.Errorf("expected name label with count 2, got:\n%s", got)
-	}
-	if !strings.Contains(got, "Zebra Artist (1):") {
-		t.Errorf("expected name label with count 1, got:\n%s", got)
-	}
-	if strings.Index(got, "Alpha Artist") > strings.Index(got, "Zebra Artist") {
-		t.Errorf("artists not sorted by name: got:\n%s", got)
-	}
-}
-
-func TestFormatDigest_FallsBackToIDWhenNameMissing(t *testing.T) {
-	missing := []scanner.MissingRelease{
-		{ArtistID: "art-1", Title: "Alpha", RGID: "r1"},
-		{ArtistID: "art-2", Title: "Beta", RGID: "r2"},
-	}
-	// Name map present but does not cover art-2 -> falls back to ID.
-	names := map[string]string{"art-1": "Named Artist"}
-	got := FormatDigest(missing, "", names)
-	if !strings.Contains(got, "Named Artist (1):") {
-		t.Errorf("expected named artist label, got:\n%s", got)
-	}
-	if !strings.Contains(got, "art-2 (1):") {
-		t.Errorf("expected ID fallback for art-2, got:\n%s", got)
-	}
-}
-
-func TestFormatDigest_EmptyUIBaseURLOmitsLink(t *testing.T) {
-	missing := []scanner.MissingRelease{{ArtistID: "a", Title: "x", RGID: "r1"}}
-	got := FormatDigest(missing, "", nil)
-	if strings.Contains(got, "View details:") {
-		t.Errorf("did not expect UI link when base URL empty: got:\n%s", got)
-	}
-}
-
-func TestTelegramSender_Success(t *testing.T) {
-	var gotReq sendMessageRequest
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/botTOKEN/sendMessage" {
-			t.Errorf("unexpected path %q", r.URL.Path)
-		}
-		if err := json.NewDecoder(r.Body).Decode(&gotReq); err != nil {
-			t.Fatalf("decode: %v", err)
-		}
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"ok":true}`))
-	}))
-	defer srv.Close()
-
-	s := &telegramSender{
-		httpClient: srv.Client(),
-		token:      "TOKEN",
-		chatID:     "CHAT",
-		baseURL:    srv.URL,
-	}
-	if err := s.Send(context.Background(), "hello"); err != nil {
-		t.Fatalf("Send returned error: %v", err)
-	}
-	if gotReq.ChatID != "CHAT" || gotReq.Text != "hello" || !gotReq.DisableWebPagePreview {
-		t.Errorf("unexpected payload: %+v", gotReq)
-	}
-}
-
-func TestTelegramSender_Non2xxError(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusUnauthorized)
-		_, _ = w.Write([]byte(`{"description":"Unauthorized"}`))
-	}))
-	defer srv.Close()
-
-	s := &telegramSender{
-		httpClient: srv.Client(),
-		token:      "TOKEN",
-		chatID:     "CHAT",
-		baseURL:    srv.URL,
-	}
-	err := s.Send(context.Background(), "hi")
-	if err == nil {
-		t.Fatal("expected error on non-2xx")
-	}
-	if !strings.Contains(err.Error(), "401") {
-		t.Errorf("expected status in error, got: %v", err)
-	}
-}
-
-func TestSenderInterfaceFailurePropagated(t *testing.T) {
-	// Verifies the Sender interface can be used by callers and failures surface.
-	want := errors.New("boom")
-	s := &stubSender{failErr: want}
-	err := s.Send(context.Background(), "msg")
-	if !errors.Is(err, want) {
-		t.Fatalf("expected wrapped error %v, got %v", want, err)
-	}
-}

internal/notifier/scheduler.go

@@ -1,179 +0,0 @@
-package notifier
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"time"
-
-	"naviwatcher/internal/config"
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/scanner"
-)
-
-// NotifyOnce computes the releases that are genuinely missing for the user,
-// intersects that set with the releases not yet notified, builds a digest of
-// the result, sends it through the given Sender, and marks each release as
-// sent.
-//
-// "Missing" is the authoritative definition produced by the scanner: an
-// external release with no sufficiently similar local album (see
-// scanner.ScanAll). This intersection is what keeps the digest honest: a
-// release the user already owns in Navidrome must never be reported as a new
-// missing release, even though it still counts as "unnotified" on a fresh
-// database. Releases already in notifications_sent are excluded by
-// GetUnnotifiedReleases, so the call is idempotent across runs.
-//
-// threshold is the fuzzy-similarity cutoff passed through to the scanner; 0
-// selects the scanner's default. It must match config.Scanner.FuzzyThreshold
-// so the digest honors the operator's configured tolerance.
-//
-// If there are no newly-missing releases nothing is sent (the caller's
-// scheduler is responsible for not spamming the operator with an empty
-// digest). When releases are present, each is marked sent so a subsequent run
-// will not re-notify it.
-//
-// uiBaseURL is the externally-reachable base URL of the Web UI, appended to the
-// digest so operators can jump to the dashboard.
-func NotifyOnce(ctx context.Context, db *database.DB, sender Sender, cfg config.TelegramConfig, uiBaseURL string, threshold float64) (int, error) {
-	if sender == nil {
-		return 0, fmt.Errorf("notifier: sender must not be nil")
-	}
-
-	// Authoritative missing set: external releases with no matching local album.
-	// This is what the Web UI dashboard also shows, so the digest stays
-	// consistent with what the operator sees in the UI.
-	// Using composite key ArtistID|RGID to be defensive - while MusicBrainz RGIDs are
-	// globally unique (UUIDs), this protects against potential data inconsistencies.
-	missing, err := scanner.ScanAll(ctx, db, threshold)
-	if err != nil {
-		return 0, fmt.Errorf("notifier: scan missing releases: %w", err)
-	}
-	missingByArtistRGID := make(map[string]scanner.MissingRelease, len(missing))
-	for _, m := range missing {
-		key := m.ArtistID + "|" + m.RGID
-		missingByArtistRGID[key] = m
-	}
-
-	// Restrict to releases not yet notified. A release that is genuinely missing
-	// but was already announced is dropped here so it is never re-sent.
-	unnotified, err := database.GetUnnotifiedReleases(db)
-	if err != nil {
-		return 0, fmt.Errorf("notifier: query unnotified releases: %w", err)
-	}
-
-	toNotify := make([]scanner.MissingRelease, 0, len(unnotified))
-	for _, r := range unnotified {
-		key := r.ArtistID + "|" + r.RGID
-		if m, ok := missingByArtistRGID[key]; ok {
-			toNotify = append(toNotify, m)
-		}
-	}
-
-	// Resolve human-readable artist names so the digest shows recognizable
-	// labels instead of opaque internal artist IDs. A lookup failure for a
-	// single artist must not abort the whole digest, so errors are ignored and
-	// that artist falls back to its ID via artistLabel.
-	names := make(map[string]string, len(toNotify))
-	for _, m := range toNotify {
-		if _, ok := names[m.ArtistID]; ok {
-			continue
-		}
-		settings, err := database.GetArtistSettings(db, m.ArtistID)
-		if err == nil && settings.Name != "" {
-			names[m.ArtistID] = settings.Name
-		}
-	}
-
-	// Nothing to report: skip sending so the operator is not spammed with an
-	// empty digest on every cron fire. The startup fire likewise stays quiet
-	// until the first genuinely missing release appears.
-	if len(toNotify) == 0 {
-		return 0, nil
-	}
-
-	message := FormatDigest(toNotify, uiBaseURL, names)
-	if err := sender.Send(ctx, message); err != nil {
-		return 0, fmt.Errorf("notifier: send digest: %w", err)
-	}
-
-	// The digest has already been delivered at this point. A failure to mark a
-	// single release must NOT abort the loop: doing so would leave later
-	// releases unmarked and cause them to be re-notified (duplicate digest) on
-	// the next run. Log and continue so every release in this batch is marked.
-	for _, m := range toNotify {
-		if err := database.MarkNotificationSent(db, m.RGID); err != nil {
-			log.Printf("notifier: mark sent for %s failed: %v", m.RGID, err)
-		}
-	}
-	return len(toNotify), nil
-}
-
-// Schedule produces the next firing time strictly after the given time. It
-// mirrors the robfig/cron Schedule interface so cron specs and simple
-// interval-based schedules are interchangeable and testable.
-type Schedule interface {
-	Next(time.Time) time.Time
-}
-
-// notifyFunc is the unit of work the scheduler runs on each firing. It mirrors
-// the signature of NotifyOnce so the scheduler can be tested with a stub.
-type notifyFunc func(ctx context.Context) error
-
-// StartScheduler runs the notify function on a schedule until ctx is cancelled.
-// It is no-op-safe: if enabled is false it returns immediately without starting
-// a goroutine. Each firing runs synchronously (in the scheduler's own
-// goroutine): NotifyOnce reads the unnotified set and marks releases sent
-// non-atomically, so overlapping runs would double-send the digest. Running one
-// fire at a time keeps the read-send-mark sequence safe; the next tick is still
-// computed from the wall clock and does not drift.
-//
-// The schedule and notify function are injectable so tests can drive a fixed or
-// frequent schedule without a real cron spec or Telegram server.
-func StartScheduler(ctx context.Context, enabled bool, schedule Schedule, notify notifyFunc, now func() time.Time) {
-	if !enabled || schedule == nil || notify == nil {
-		log.Println("Notifier scheduler disabled or misconfigured; not starting.")
-		return
-	}
-	if now == nil {
-		now = time.Now
-	}
-
-	go func() {
-		timer := time.NewTimer(0)
-		defer timer.Stop()
-		// Fire immediately on start (startup digest), then schedule subsequent runs.
-		first := true
-		for {
-			var wait time.Duration
-			if first {
-				first = false
-				wait = 0
-			} else {
-				next := schedule.Next(now())
-				if next.IsZero() {
-					log.Println("Notifier schedule has no next fire; stopping scheduler.")
-					return
-				}
-				wait = time.Until(next)
-				if wait < 0 {
-					wait = 0
-				}
-			}
-
-			timer.Reset(wait)
-			select {
-			case <-ctx.Done():
-				log.Println("Notifier scheduler stopped.")
-				return
-			case <-timer.C:
-				if err := notify(ctx); err != nil {
-					if ctx.Err() != nil {
-						return
-					}
-					log.Printf("Notifier run failed: %v", err)
-				}
-			}
-		}
-	}()
-}

internal/notifier/scheduler_test.go

@@ -1,368 +0,0 @@
-package notifier
-
-import (
-	"context"
-	"errors"
-	"sync"
-	"testing"
-	"time"
-
-	"naviwatcher/internal/config"
-	"naviwatcher/internal/database"
-)
-
-// fixedSchedule is a test Schedule that fires a fixed duration after every call
-// to Next, so a scheduler test can run deterministically without a real cron.
-type fixedSchedule struct {
-	interval time.Duration
-}
-
-func (f fixedSchedule) Next(t time.Time) time.Time {
-	return t.Add(f.interval)
-}
-
-// collectSender records messages and can be told to fail.
-type collectSender struct {
-	mu       sync.Mutex
-	messages []string
-	failErr  error
-}
-
-func (s *collectSender) Send(ctx context.Context, message string) error {
-	if s.failErr != nil {
-		return s.failErr
-	}
-	s.mu.Lock()
-	s.messages = append(s.messages, message)
-	s.mu.Unlock()
-	return nil
-}
-
-func (s *collectSender) count() int {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	return len(s.messages)
-}
-
-// seedRelease inserts an external_release row (with an artist) and optionally
-// marks it as already notified. Returns the rgid.
-func seedRelease(t *testing.T, db *database.DB, rgid, artistID string, notified bool) {
-	t.Helper()
-	if _, err := db.Conn().Exec(
-		"INSERT OR IGNORE INTO artist_settings (id, name) VALUES (?, ?)",
-		artistID, "Test Artist "+artistID,
-	); err != nil {
-		t.Fatalf("seed artist: %v", err)
-	}
-	if _, err := db.Conn().Exec(
-		"INSERT INTO external_releases (rgid, artist_id, title, type, release_date) VALUES (?, ?, ?, ?, ?)",
-		rgid, artistID, "Release "+rgid, "album", "",
-	); err != nil {
-		t.Fatalf("seed release: %v", err)
-	}
-	if notified {
-		if err := database.MarkNotificationSent(db, rgid); err != nil {
-			t.Fatalf("mark sent: %v", err)
-		}
-	}
-}
-
-func TestNotifyOnce_SendsAndMarksSent(t *testing.T) {
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("New(): %v", err)
-	}
-	defer db.Close()
-
-	seedRelease(t, db, "rgid-1", "artist-1", false)
-	seedRelease(t, db, "rgid-2", "artist-1", false)
-
-	sender := &collectSender{}
-	cfg := config.TelegramConfig{Enabled: true}
-	n, err := NotifyOnce(context.Background(), db, sender, cfg, "http://ui:8080", 0.85)
-	if err != nil {
-		t.Fatalf("NotifyOnce: %v", err)
-	}
-	if n != 2 {
-		t.Fatalf("expected 2 releases notified, got %d", n)
-	}
-	if sender.count() != 1 {
-		t.Fatalf("expected a single digest message, got %d", sender.count())
-	}
-
-	// After notifying, both should now be considered sent.
-	remaining, err := database.GetUnnotifiedReleases(db)
-	if err != nil {
-		t.Fatalf("GetUnnotifiedReleases: %v", err)
-	}
-	if len(remaining) != 0 {
-		t.Fatalf("expected 0 unnotified after NotifyOnce, got %d", len(remaining))
-	}
-}
-
-func TestNotifyOnce_OwnedReleaseNotNotified(t *testing.T) {
-	// Regression: a cached external release the user already owns locally must
-	// not be reported as "missing". Before the scanner intersection was added,
-	// NotifyOnce treated every unnotified external release as missing and would
-	// spam the operator with releases they already have in Navidrome.
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("New(): %v", err)
-	}
-	defer db.Close()
-
-	seedRelease(t, db, "rgid-owned", "artist-1", false)
-	// The user already has this album locally, with a matching normalized title.
-	if _, err := db.Conn().Exec(
-		"INSERT INTO local_albums (id, artist_id, title) VALUES (?, ?, ?)",
-		"local-1", "artist-1", "Release rgid-owned",
-	); err != nil {
-		t.Fatalf("seed local album: %v", err)
-	}
-
-	sender := &collectSender{}
-	n, err := NotifyOnce(context.Background(), db, sender, config.TelegramConfig{}, "http://ui", 0.85)
-	if err != nil {
-		t.Fatalf("NotifyOnce: %v", err)
-	}
-	if n != 0 {
-		t.Fatalf("expected 0 notified (release already owned), got %d", n)
-	}
-	if sender.count() != 0 {
-		t.Fatalf("expected no digest for an owned release, got %d message(s)", sender.count())
-	}
-	// The owned release is genuinely missing per the scanner, so it must remain
-	// un-marked-sent to avoid corrupting notifications_sent state.
-	sent, err := database.IsNotificationSent(db, "rgid-owned")
-	if err != nil {
-		t.Fatalf("IsNotificationSent: %v", err)
-	}
-	if sent {
-		t.Error("owned release should NOT be marked sent")
-	}
-}
-
-func TestNotifyOnce_EmptyDoesNotSend(t *testing.T) {
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("New(): %v", err)
-	}
-	defer db.Close()
-
-	sender := &collectSender{}
-	n, err := NotifyOnce(context.Background(), db, sender, config.TelegramConfig{}, "http://ui", 0.85)
-	if err != nil {
-		t.Fatalf("NotifyOnce: %v", err)
-	}
-	if n != 0 {
-		t.Fatalf("expected 0 releases notified, got %d", n)
-	}
-	if sender.count() != 0 {
-		t.Fatalf("expected no message sent for empty digest, got %d", sender.count())
-	}
-}
-
-func TestNotifyOnce_SkipsAlreadySent(t *testing.T) {
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("New(): %v", err)
-	}
-	defer db.Close()
-
-	// One already-notified, one new.
-	seedRelease(t, db, "rgid-done", "artist-1", true)
-	seedRelease(t, db, "rgid-new", "artist-1", false)
-
-	sender := &collectSender{}
-	n, err := NotifyOnce(context.Background(), db, sender, config.TelegramConfig{}, "http://ui", 0.85)
-	if err != nil {
-		t.Fatalf("NotifyOnce: %v", err)
-	}
-	if n != 1 {
-		t.Fatalf("expected 1 newly notified release, got %d", n)
-	}
-
-	// The already-sent one stays marked sent; the new one is now marked.
-	done, err := database.IsNotificationSent(db, "rgid-done")
-	if err != nil {
-		t.Fatalf("IsNotificationSent done: %v", err)
-	}
-	if !done {
-		t.Error("expected rgid-done to remain sent")
-	}
-	newsent, err := database.IsNotificationSent(db, "rgid-new")
-	if err != nil {
-		t.Fatalf("IsNotificationSent new: %v", err)
-	}
-	if !newsent {
-		t.Error("expected rgid-new to be marked sent")
-	}
-}
-
-func TestNotifyOnce_SendErrorNotMarked(t *testing.T) {
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("New(): %v", err)
-	}
-	defer db.Close()
-
-	seedRelease(t, db, "rgid-1", "artist-1", false)
-
-	want := errors.New("send boom")
-	sender := &collectSender{failErr: want}
-	_, err = NotifyOnce(context.Background(), db, sender, config.TelegramConfig{}, "http://ui", 0.85)
-	if err == nil || !errors.Is(err, want) {
-		t.Fatalf("expected error %v, got %v", want, err)
-	}
-	// On send failure nothing should be marked sent.
-	sent, err := database.IsNotificationSent(db, "rgid-1")
-	if err != nil {
-		t.Fatalf("IsNotificationSent: %v", err)
-	}
-	if sent {
-		t.Error("release should NOT be marked sent when send fails")
-	}
-}
-
-func TestNotifyOnce_NilSender(t *testing.T) {
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("New(): %v", err)
-	}
-	defer db.Close()
-
-	if _, err := NotifyOnce(context.Background(), db, nil, config.TelegramConfig{}, "http://ui", 0.85); err == nil {
-		t.Fatal("expected error for nil sender")
-	}
-}
-
-func TestStartScheduler_FiresOnSchedule(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	var mu sync.Mutex
-	var calls int
-	notify := func(ctx context.Context) error {
-		mu.Lock()
-		calls++
-		mu.Unlock()
-		return nil
-	}
-
-	// Fixed 10ms interval schedule; injected now func is unused by fixedSchedule.
-	StartScheduler(ctx, true, fixedSchedule{interval: 10 * time.Millisecond}, notify, time.Now)
-
-	// Allow a few ticks (immediate fire + scheduled ones).
-	time.Sleep(60 * time.Millisecond)
-	cancel()
-
-	mu.Lock()
-	got := calls
-	mu.Unlock()
-	if got < 2 {
-		t.Fatalf("expected scheduler to fire at least twice, got %d", got)
-	}
-}
-
-func TestStartScheduler_DisabledNoOp(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	fired := false
-	notify := func(ctx context.Context) error {
-		fired = true
-		return nil
-	}
-	StartScheduler(ctx, false, fixedSchedule{interval: time.Millisecond}, notify, time.Now)
-	time.Sleep(20 * time.Millisecond)
-	if fired {
-		t.Fatal("scheduler should not fire when disabled")
-	}
-}
-
-func TestCronSchedule_ParsesAndNext(t *testing.T) {
-	s, err := NewCronSchedule("0 9 * * *")
-	if err != nil {
-		t.Fatalf("NewCronSchedule: %v", err)
-	}
-	base := time.Date(2026, 7, 19, 10, 0, 0, 0, time.Local)
-	next := s.Next(base)
-	// After 10:00, the next 09:00 daily fire is the next day.
-	if next.Day() != 20 || next.Hour() != 9 {
-		t.Fatalf("expected next fire at 09:00 next day, got %v", next)
-	}
-}
-
-func TestCronSchedule_InvalidSpec(t *testing.T) {
-	if _, err := NewCronSchedule("not a cron"); err == nil {
-		t.Fatal("expected error for invalid cron spec")
-	}
-}
-
-// TestNotifyOnce_CompositeKey verifies that the NotifyOnce function correctly
-// uses ArtistID|RGID as the composite key for matching missing releases
-// with unnotified releases.
-// Note: Due to the current database schema only tracking RGID in notifications_sent
-// (not ArtistID|RGID), when one artist's release is marked as sent, it affects
-// all artists with that RGID. This test verifies our in-memory composite key logic
-// works correctly despite this limitation.
-func TestNotifyOnce_CompositeKey(t *testing.T) {
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("New(): %v", err)
-	}
-	defer db.Close()
-
-	// Create two different artists with different RGIDs to test the composite key logic
-	rgid1 := "rgid-1"
-	rgid2 := "rgid-2"
-	artistID := "artist-1"
-
-	// Seed artist settings
-	if _, err := db.Conn().Exec(
-		"INSERT OR IGNORE INTO artist_settings (id, name) VALUES (?, ?)",
-		artistID, "Test Artist",
-	); err != nil {
-		t.Fatalf("seed artist: %v", err)
-	}
-
-	// Seed external releases for the same artist but different RGIDs
-	if _, err := db.Conn().Exec(
-		"INSERT INTO external_releases (rgid, artist_id, title, type, release_date) VALUES (?, ?, ?, ?, ?)",
-		rgid1, artistID, "Release 1", "album", "",
-	); err != nil {
-		t.Fatalf("seed release 1: %v", err)
-	}
-	if _, err := db.Conn().Exec(
-		"INSERT INTO external_releases (rgid, artist_id, title, type, release_date) VALUES (?, ?, ?, ?, ?)",
-		rgid2, artistID, "Release 2", "album", "",
-	); err != nil {
-		t.Fatalf("seed release 2: %v", err)
-	}
-
-	// Note: We don't mock scanner.ScanAll here because it's difficult to replace
-	// package-level variables in tests. Instead we rely on the existing tests
-	// to verify the scanning logic works, and this test focuses on verifying
-	// our composite key mapping logic executes without errors.
-
-	// Seed one of the releases as already notified
-	if err := database.MarkNotificationSent(db, rgid1); err != nil {
-		t.Fatalf("mark sent: %v", err)
-	}
-
-	sender := &collectSender{}
-	cfg := config.TelegramConfig{Enabled: true}
-
-	// NotifyOnce should process the releases and return a count
-	n, err := NotifyOnce(context.Background(), db, sender, cfg, "http://ui:8080", 0.85)
-	if err != nil {
-		t.Fatalf("NotifyOnce: %v", err)
-	}
-
-	// Verify that our composite key logic is working by ensuring the function completed
-	// without error and processed the data (the exact count depends on what scanner.ScanAll returns)
-	// The key assertion is that it doesn't panic and returns a reasonable count
-	if n < 0 {
-		t.Fatalf("expected non-negative notification count, got %d", n)
-	}
-}

internal/notifier/sender.go

@@ -1,78 +0,0 @@
-package notifier
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"time"
-
-	"naviwatcher/internal/config"
-)
-
-// Sender delivers a notification message to a destination (e.g. Telegram).
-// It is an interface so the real HTTP bot can be swapped for a stub in tests.
-type Sender interface {
-	Send(ctx context.Context, message string) error
-}
-
-// telegramSender sends messages via the Telegram Bot API sendMessage method.
-type telegramSender struct {
-	httpClient *http.Client
-	token      string
-	chatID     string
-	baseURL    string
-}
-
-// NewTelegramSender constructs a Sender that posts to the Telegram Bot API
-// using the token and chat ID from the given TelegramConfig.
-func NewTelegramSender(cfg config.TelegramConfig) *telegramSender {
-	return &telegramSender{
-		httpClient: &http.Client{Timeout: 30 * time.Second},
-		token:      cfg.Token,
-		chatID:     cfg.ChatID,
-		baseURL:    "https://api.telegram.org",
-	}
-}
-
-// sendMessageRequest is the JSON payload for the Telegram sendMessage endpoint.
-type sendMessageRequest struct {
-	ChatID                string `json:"chat_id"`
-	Text                  string `json:"text"`
-	DisableWebPagePreview bool   `json:"disable_web_page_preview"`
-}
-
-// Send posts the message to the configured Telegram chat. It returns an error
-// if the request cannot be built/sent or the API responds with a non-2xx code.
-func (s *telegramSender) Send(ctx context.Context, message string) error {
-	payload := sendMessageRequest{
-		ChatID:                s.chatID,
-		Text:                  message,
-		DisableWebPagePreview: true,
-	}
-	body, err := json.Marshal(payload)
-	if err != nil {
-		return fmt.Errorf("marshal telegram payload: %w", err)
-	}
-
-	url := fmt.Sprintf("%s/bot%s/sendMessage", s.baseURL, s.token)
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
-	if err != nil {
-		return fmt.Errorf("build telegram request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	resp, err := s.httpClient.Do(req)
-	if err != nil {
-		return fmt.Errorf("send telegram message: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		respBody, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
-		return fmt.Errorf("telegram API returned status %d: %s", resp.StatusCode, string(respBody))
-	}
-	return nil
-}

internal/scanner/diff.go

@@ -1,91 +0,0 @@
-package scanner
-
-import (
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/musicbrainz"
-)
-
-// MissingRelease describes an external release that has no sufficiently similar
-// local album. It is a flattened, consumer-friendly projection of a
-// database.ExternalRelease.
-type MissingRelease struct {
-	RGID        string `json:"rgid"`
-	ArtistID    string `json:"artist_id"`
-	Title       string `json:"title"`
-	Type        string `json:"type"`
-	ReleaseDate string `json:"release_date"`
-}
-
-// FilterIsSuppressed reports whether an external release is dropped by the type toggles.
-// A release counts as a Single/Compilation via either its primary Type or its
-// secondary types, matching musicbrainz.FilterReleaseGroups so both the
-// cache-miss (store-time) and read-time paths agree.
-//
-// This function reuses the centralized filtering logic from the musicbrainz
-// package to ensure consistency between the scanner's read-time filtering
-// and the MusicBrainz sync's store-time filtering.
-func FilterIsSuppressed(filter musicbrainz.FilterOptions, ext database.ExternalRelease) bool {
-	filtered := musicbrainz.ApplyTypeToggles([]database.ExternalRelease{ext}, filter)
-	return len(filtered) == 0
-}
-
-// FindMissingReleases compares an artist's external discography against the
-// user's local albums and returns the releases that are present externally but
-// have no sufficiently similar local album.
-//
-// Rules:
-//   - External releases flagged IsIgnored are never reported.
-//   - External releases suppressed by the per-artist type toggles (filter) are
-//     never reported.
-//   - A local album only matches an external release for the same ArtistID.
-//   - An external release is "missing" when none of the local albums (same
-//     ArtistID) IsMatch at the given threshold.
-//
-// The filter.suppressed() check applies the same IgnoreSingles/IgnoreCompilations
-// filtering logic as used in the MusicBrainz sync path, ensuring consistent
-// behavior between cache-hit (read-time) and cache-miss (store-time) paths.
-func FindMissingReleases(local []database.LocalAlbum, external []database.ExternalRelease, threshold float64, filter musicbrainz.FilterOptions) []MissingRelease {
-	// Resolve the threshold exactly as ScanArtist/ScanAll do, so the exported
-	// primitive honors the same zero-means-default contract rather than treating
-	// 0 as "always match" (which would report nothing as missing).
-	threshold = resolveThreshold(threshold)
-
-	// Group local albums by artist for O(1) lookup per external release.
-	localByArtist := make(map[string][]database.LocalAlbum)
-	for _, a := range local {
-		localByArtist[a.ArtistID] = append(localByArtist[a.ArtistID], a)
-	}
-
-	var missing []MissingRelease
-	for _, ext := range external {
-		if ext.IsIgnored {
-			continue
-		}
-		if FilterIsSuppressed(filter, ext) {
-			continue
-		}
-
-		albums := localByArtist[ext.ArtistID]
-		matched := false
-		for _, a := range albums {
-			if IsMatch(a.Title, ext.Title, threshold) {
-				matched = true
-				break
-			}
-		}
-
-		if matched {
-			continue
-		}
-
-		missing = append(missing, MissingRelease{
-			RGID:        ext.RGID,
-			ArtistID:    ext.ArtistID,
-			Title:       ext.Title,
-			Type:        ext.Type,
-			ReleaseDate: ext.ReleaseDate,
-		})
-	}
-
-	return missing
-}

internal/scanner/diff_test.go

@@ -1,150 +0,0 @@
-package scanner
-
-import (
-	"testing"
-
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/musicbrainz"
-)
-
-func TestFilterIsSuppressedMatchesMusicbrainzFilter(t *testing.T) {
-	// Test cases covering various combinations of types and secondary types
-	testCases := []struct {
-		name               string
-		releaseType        string
-		secondaryTypes     []string
-		ignoreSingles      bool
-		ignoreCompilations bool
-		expectedSuppressed bool
-	}{
-		// Single type tests
-		{"Single primary type", "Single", []string{}, true, false, true},
-		{"Single primary type with EP ignore", "Single", []string{}, false, true, false},
-
-		// EP as primary type (should be treated as Single when IgnoreSingles=true)
-		{"EP primary type", "EP", []string{}, true, false, true},
-		{"EP primary type with EP ignore", "EP", []string{}, false, true, false},
-
-		// Album type tests
-		{"Album primary type", "Album", []string{}, true, false, false},
-		{"Album primary type with Compilation ignore", "Album", []string{}, false, true, false},
-
-		// Compilation type tests
-		{"Compilation primary type", "Compilation", []string{}, true, false, false},
-		{"Compilation primary type with Compilation ignore", "Compilation", []string{}, false, true, true},
-
-		// Secondary types - Single
-		{"Album with Single secondary", "Album", []string{"Single"}, true, false, true},
-		{"Album with Single secondary (no ignore)", "Album", []string{"Single"}, false, false, false},
-		{"EP with Single secondary", "EP", []string{"Single"}, true, false, true},
-
-		// Secondary types - EP (should trigger Single ignore)
-		{"Album with EP secondary", "Album", []string{"EP"}, true, false, true},
-		{"Album with EP secondary (no ignore)", "Album", []string{"EP"}, false, false, false},
-
-		// Secondary types - Compilation
-		{"Album with Compilation secondary", "Album", []string{"Compilation"}, true, false, false},
-		{"Album with Compilation secondary (with ignore)", "Album", []string{"Compilation"}, false, true, true},
-
-		// Multiple secondary types
-		{"Album with Single and EP secondary", "Album", []string{"Single", "EP"}, true, false, true},
-		{"Album with Compilation secondary", "Album", []string{"Compilation"}, false, true, true},
-		{"Album with multiple secondary types", "Album", []string{"Single", "Compilation"}, true, true, true},
-
-		// Edge cases
-		{"Empty types", "", []string{}, false, false, false},
-		{"Unknown type", "Live", []string{}, false, false, false},
-	}
-
-	for _, tc := range testCases {
-		tc := tc // capture range variable
-		t.Run(tc.name, func(t *testing.T) {
-			// Create test release
-			release := database.ExternalRelease{
-				Type:           tc.releaseType,
-				SecondaryTypes: tc.secondaryTypes,
-			}
-
-			// Test scanner filter
-			scannerFilter := musicbrainz.FilterOptions{
-				IgnoreSingles:      tc.ignoreSingles,
-				IgnoreCompilations: tc.ignoreCompilations,
-			}
-			scannerSuppressed := FilterIsSuppressed(scannerFilter, release)
-
-			// Test musicbrainz filter
-			mbFilter := musicbrainz.FilterOptions{
-				IgnoreSingles:      tc.ignoreSingles,
-				IgnoreCompilations: tc.ignoreCompilations,
-			}
-			mbFiltered := musicbrainz.ApplyTypeToggles([]database.ExternalRelease{release}, mbFilter)
-			mbSuppressed := len(mbFiltered) == 0
-
-			// Both should agree
-			if scannerSuppressed != mbSuppressed {
-				t.Errorf("Scanner and MusicBrainz filter disagree for %v: scanner=%v, musicbrainz=%v",
-					tc, scannerSuppressed, mbSuppressed)
-			}
-
-			// Check against expected value
-			if scannerSuppressed != tc.expectedSuppressed {
-				t.Errorf("Scanner filter returned %v, expected %v for case %v",
-					scannerSuppressed, tc.expectedSuppressed, tc.name)
-			}
-		})
-	}
-}
-
-// Test that verifies the specific case mentioned in the issue: EP in SecondaryTypes counts as Single
-func TestFilterIsSuppressedTreatsEPAsSingleWhenIgnoreSingles(t *testing.T) {
-	testCases := []struct {
-		name               string
-		releaseType        string
-		secondaryTypes     []string
-		ignoreSingles      bool
-		ignoreCompilations bool
-		expectedSuppressed bool
-	}{
-		{"Album with EP secondary - should be suppressed when IgnoreSingles=true", "Album", []string{"EP"}, true, false, true},
-		{"Album with EP secondary - should NOT be suppressed when IgnoreSingles=false", "Album", []string{"EP"}, false, false, false},
-		{"Single with EP secondary - should be suppressed when IgnoreSingles=true", "Single", []string{"EP"}, true, false, true},
-		{"Compilation with EP secondary - should be suppressed when IgnoreSingles=true (because EP in secondary counts as Single)", "Compilation", []string{"EP"}, true, false, true},
-	}
-
-	for _, tc := range testCases {
-		tc := tc // capture range variable
-		t.Run(tc.name, func(t *testing.T) {
-			// Create test release
-			release := database.ExternalRelease{
-				Type:           tc.releaseType,
-				SecondaryTypes: tc.secondaryTypes,
-			}
-
-			// Test scanner filter
-			scannerFilter := musicbrainz.FilterOptions{
-				IgnoreSingles:      tc.ignoreSingles,
-				IgnoreCompilations: tc.ignoreCompilations,
-			}
-			scannerSuppressed := FilterIsSuppressed(scannerFilter, release)
-
-			// Test musicbrainz filter
-			mbFilter := musicbrainz.FilterOptions{
-				IgnoreSingles:      tc.ignoreSingles,
-				IgnoreCompilations: tc.ignoreCompilations,
-			}
-			mbFiltered := musicbrainz.ApplyTypeToggles([]database.ExternalRelease{release}, mbFilter)
-			mbSuppressed := len(mbFiltered) == 0
-
-			// Both should agree and match expected
-			if scannerSuppressed != mbSuppressed {
-				t.Errorf("Scanner and MusicBrainz filter disagree for %v: scanner=%v, musicbrainz=%v",
-					tc, scannerSuppressed, mbSuppressed)
-			}
-
-			if scannerSuppressed != tc.expectedSuppressed {
-				t.Errorf("Filter returned %v, expected %v for case %v",
-					scannerSuppressed, tc.expectedSuppressed, tc.name)
-			}
-		})
-	}
-}

internal/scanner/scan.go

@@ -1,103 +0,0 @@
-package scanner
-
-import (
-	"context"
-	"log"
-
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/musicbrainz"
-)
-
-// ScanArtist loads the local albums and external releases for a single artist
-// from the database and computes the list of missing releases.
-//
-// threshold is the fuzzy-similarity cutoff; pass 0 to use DefaultThreshold.
-// The context is checked before querying the database; if it is already
-// cancelled, no work is performed and the sentinel error ctx.Err() is returned.
-func ScanArtist(ctx context.Context, db *database.DB, artistID string, threshold float64) ([]MissingRelease, error) {
-	if err := ctx.Err(); err != nil {
-		return nil, err
-	}
-
-	local, err := database.GetLocalAlbumsByArtist(db, artistID)
-	if err != nil {
-		return nil, err
-	}
-
-	external, err := database.GetExternalReleasesByArtist(db, artistID)
-	if err != nil {
-		return nil, err
-	}
-
-	// Apply the artist's type toggles at read time so ignore_singles /
-	// ignore_compilations changes take effect immediately, without waiting for
-	// the MusicBrainz cache to expire and prune rows on the next re-sync.
-	// This ensures that changes to ignore_singles/ignore_compilations take
-	// effect immediately in the scanner, providing real-time responsiveness
-	// to user preference changes.
-	settings, err := database.GetArtistSettings(db, artistID)
-	if err != nil {
-		// If artist settings don't exist, use empty filter (no filtering)
-		if err == database.ErrArtistNotFound {
-			filter := musicbrainz.FilterOptions{
-				IgnoreSingles:      false,
-				IgnoreCompilations: false,
-			}
-			missing := FindMissingReleases(local, external, threshold, filter)
-			return missing, nil
-		}
-		return nil, err
-	}
-	filter := musicbrainz.FilterOptions{
-		IgnoreSingles:      settings.IgnoreSingles,
-		IgnoreCompilations: settings.IgnoreCompilations,
-	}
-
-	missing := FindMissingReleases(local, external, threshold, filter)
-	return missing, nil
-}
-
-// ScanAll iterates over all monitored artists (those with Monitored == true)
-// and computes the missing releases for each. Results are concatenated into a
-// single slice across all artists.
-//
-// The function retrieves all artist settings once and then calls ScanArtist
-// for each monitored artist, ensuring consistent application of
-// ignore_singles/ignore_compilations filters across all artists.
-//
-// ctx.Err() is checked between artists; if cancellation occurs mid-iteration,
-// scanning stops early and the accumulated results so far are returned along
-// with the cancellation error. threshold follows the same contract as
-// ScanArtist (0 → DefaultThreshold).
-func ScanAll(ctx context.Context, db *database.DB, threshold float64) ([]MissingRelease, error) {
-	settings, err := database.GetAllArtistSettings(db)
-	if err != nil {
-		return nil, err
-	}
-
-	var all []MissingRelease
-	var failedArtists []string
-	for _, s := range settings {
-		if err := ctx.Err(); err != nil {
-			return all, err
-		}
-		if !s.Monitored {
-			continue
-		}
-		// A transient error for one artist must not abort the whole scan and
-		// take down the daemon; log it and continue with the remaining artists.
-		missing, err := ScanArtist(ctx, db, s.ID, threshold)
-		if err != nil {
-			log.Printf("scan artist %s failed: %v", s.ID, err)
-			failedArtists = append(failedArtists, s.ID)
-			continue
-		}
-		all = append(all, missing...)
-	}
-
-	if n := len(failedArtists); n > 0 {
-		log.Printf("scan completed with %d artist(s) skipped due to errors: %v", n, failedArtists)
-	}
-
-	return all, nil
-}

internal/scanner/scan_test.go

@@ -1,458 +0,0 @@
-package scanner
-
-import (
-	"context"
-	"testing"
-
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/musicbrainz"
-)
-
-// newTestDB creates an in-memory SQLite database with all migrations applied.
-func newTestDB(t *testing.T) *database.DB {
-	t.Helper()
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("database.New() error: %v", err)
-	}
-	return db
-}
-
-// seedArtist inserts a minimal artist_settings row so FK constraints pass.
-func seedArtist(t *testing.T, db *database.DB, id, name string) {
-	t.Helper()
-	if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-		ID:        id,
-		Name:      name,
-		Monitored: true,
-	}); err != nil {
-		t.Fatalf("seedArtist(%s) error: %v", id, err)
-	}
-}
-
-// seedLocalAlbum inserts a local_albums row for an artist.
-func seedLocalAlbum(t *testing.T, db *database.DB, id, artistID, title string) {
-	t.Helper()
-	if err := database.SaveLocalAlbum(db, &database.LocalAlbum{
-		ID:       id,
-		ArtistID: artistID,
-		Title:    title,
-	}); err != nil {
-		t.Fatalf("seedLocalAlbum(%s) error: %v", id, err)
-	}
-}
-
-// seedExternalRelease inserts an external_releases row for an artist.
-func seedExternalRelease(t *testing.T, db *database.DB, rgid, artistID, title string, ignored bool) {
-	t.Helper()
-	if err := database.SaveExternalRelease(db, &database.ExternalRelease{
-		RGID:      rgid,
-		ArtistID:  artistID,
-		Title:     title,
-		IsIgnored: ignored,
-	}); err != nil {
-		t.Fatalf("seedExternalRelease(%s) error: %v", rgid, err)
-	}
-}
-
-// TestScanArtist verifies the basic functionality of ScanArtist.
-func TestScanArtist(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-
-	seedArtist(t, db, "artist-1", "Pink Floyd")
-
-	// Local collection has "The Wall" but not "Animals".
-	seedLocalAlbum(t, db, "l1", "artist-1", "The Wall")
-	seedExternalRelease(t, db, "rg1", "artist-1", "The Wall", false)
-	seedExternalRelease(t, db, "rg2", "artist-1", "Animals", false)
-
-	missing, err := ScanArtist(context.Background(), db, "artist-1", 0)
-	if err != nil {
-		t.Fatalf("ScanArtist() error: %v", err)
-	}
-
-	rgids := map[string]bool{}
-	for _, m := range missing {
-		rgids[m.RGID] = true
-	}
-	if !rgids["rg2"] {
-		t.Errorf("expected rg2 (Animals) to be missing, got %v", rgids)
-	}
-	if rgids["rg1"] {
-		t.Errorf("did not expect rg1 (The Wall) to be missing, got %v", rgids)
-	}
-}
-
-// TestScanArtist_ZeroThresholdUsesDefault verifies that passing 0 for threshold uses DefaultThreshold.
-func TestScanArtist_ZeroThresholdUsesDefault(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-
-	seedArtist(t, db, "artist-1", "Pink Floyd")
-	seedLocalAlbum(t, db, "l1", "artist-1", "The Wall")
-	seedExternalRelease(t, db, "rg1", "artist-1", "The Wall", false)
-	seedExternalRelease(t, db, "rg2", "artist-1", "Animals", false)
-
-	// Pass 0 (zero value / unset) and the explicit default; results must match.
-	zero, err := ScanArtist(context.Background(), db, "artist-1", 0)
-	if err != nil {
-		t.Fatalf("ScanArtist(0) error: %v", err)
-	}
-	explicit, err := ScanArtist(context.Background(), db, "artist-1", DefaultThreshold)
-	if err != nil {
-		t.Fatalf("ScanArtist(%v) error: %v", DefaultThreshold, err)
-	}
-	if len(zero) != len(explicit) {
-		t.Errorf("ScanArtist(0) returned %d missing, ScanArtist(%v) returned %d; must match",
-			len(zero), DefaultThreshold, len(explicit))
-	}
-}
-
-// TestScanArtist_IgnoredNotReported verifies that ignored external releases are not reported as missing.
-func TestScanArtist_IgnoredNotReported(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-
-	seedArtist(t, db, "artist-1", "Pink Floyd")
-	seedExternalRelease(t, db, "rg1", "artist-1", "Animals", true)
-
-	missing, err := ScanArtist(context.Background(), db, "artist-1", 0.85)
-	if err != nil {
-		t.Fatalf("ScanArtist() error: %v", err)
-	}
-	if len(missing) != 0 {
-		t.Errorf("ignored release should not be reported, got %v", missing)
-	}
-}
-
-// TestScanArtist_RemasteredVariantNotMissing verifies that remastered variants matching local albums are not reported missing.
-func TestScanArtist_RemasteredVariantNotMissing(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-
-	seedArtist(t, db, "artist-1", "Pink Floyd")
-	seedLocalAlbum(t, db, "l1", "artist-1", "The Wall (Remastered)")
-	seedExternalRelease(t, db, "rg1", "artist-1", "The Wall", false)
-
-	missing, err := ScanArtist(context.Background(), db, "artist-1", 0)
-	if err != nil {
-		t.Fatalf("ScanArtist() error: %v", err)
-	}
-	if len(missing) != 0 {
-		t.Errorf("remastered local should match external, got %v", missing)
-	}
-}
-
-// TestScanArtist_YearTitledAlbumReissueReportedMissing verifies that year-titled albums are handled correctly.
-func TestScanArtist_YearTitledAlbumReissueReportedMissing(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-
-	// Rush "2112" is a bare year-titled album; "2112 (Remastered)" is a
-	// distinct release group. Owning the standard 2112 must NOT count as owning
-	// the remastered reissue — the reissue should be reported missing.
-	seedArtist(t, db, "artist-1", "Rush")
-	seedLocalAlbum(t, db, "l1", "artist-1", "2112")
-	seedExternalRelease(t, db, "rg-standard", "artist-1", "2112", false)
-	seedExternalRelease(t, db, "rg-remaster", "artist-1", "2112 (Remastered)", false)
-
-	missing, err := ScanArtist(context.Background(), db, "artist-1", 0)
-	if err != nil {
-		t.Fatalf("ScanArtist() error: %v", err)
-	}
-
-	rgids := map[string]bool{}
-	for _, m := range missing {
-		rgids[m.RGID] = true
-	}
-	if rgids["rg-standard"] {
-		t.Errorf("standard 2112 should match local copy, not be missing")
-	}
-	if !rgids["rg-remaster"] {
-		t.Errorf("2112 (Remastered) reissue should be reported missing, got %v", rgids)
-	}
-}
-
-// TestScanArtist_CtxCancelled verifies that ScanArtist respects context cancellation.
-func TestScanArtist_CtxCancelled(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-	seedArtist(t, db, "artist-1", "Pink Floyd")
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	if _, err := ScanArtist(ctx, db, "artist-1", 0.85); err == nil {
-		t.Fatal("expected error from cancelled context, got nil")
-	}
-}
-
-// TestScanAll verifies the basic functionality of ScanAll.
-func TestScanAll(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-
-	// Monitored artist with one missing release.
-	seedArtist(t, db, "artist-1", "Pink Floyd")
-	seedLocalAlbum(t, db, "l1", "artist-1", "The Wall")
-	seedExternalRelease(t, db, "rg1", "artist-1", "The Wall", false)
-	seedExternalRelease(t, db, "rg2", "artist-1", "Animals", false)
-
-	// Unmonitored artist — must be skipped entirely.
-	seedArtistUnmonitored(t, db, "artist-2", "Other")
-	seedExternalRelease(t, db, "rg3", "artist-2", "Some Album", false)
-
-	missing, err := ScanAll(context.Background(), db, 0)
-	if err != nil {
-		t.Fatalf("ScanAll() error: %v", err)
-	}
-
-	rgids := map[string]bool{}
-	for _, m := range missing {
-		rgids[m.RGID] = true
-	}
-	if !rgids["rg2"] {
-		t.Errorf("expected rg2 (Animals) missing, got %v", rgids)
-	}
-	if rgids["rg1"] {
-		t.Errorf("did not expect rg1 (The Wall) missing, got %v", rgids)
-	}
-	if rgids["rg3"] {
-		t.Errorf("unmonitored artist's release must not be scanned, got %v", rgids)
-	}
-}
-
-// TestScanAll_CtxCancelledMidIteration verifies that ScanAll respects context cancellation mid-iteration.
-func TestScanAll_CtxCancelledMidIteration(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-
-	seedArtist(t, db, "artist-1", "Pink Floyd")
-	seedArtist(t, db, "artist-2", "Other")
-
-	// Cancel before scanning starts.
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	missing, err := ScanAll(ctx, db, 0.85)
-	if err == nil {
-		t.Fatal("expected error from cancelled context, got nil")
-	}
-	if missing != nil {
-		t.Errorf("expected nil results on early cancellation, got %v", missing)
-	}
-}
-
-// seedArtistUnmonitored inserts an artist_settings row with Monitored=false.
-func seedArtistUnmonitored(t *testing.T, db *database.DB, id, name string) {
-	t.Helper()
-	if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-		ID:        id,
-		Name:      name,
-		Monitored: false,
-	}); err != nil {
-		t.Fatalf("seedArtistUnmonitored(%s) error: %v", id, err)
-	}
-}
-
-// TestScanArtist_ErrArtistNotFound verifies that ScanArtist handles ErrArtistNotFound
-// by using empty TypeFilter (no filtering) instead of returning an error.
-func TestScanArtist_ErrArtistNotFound(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-
-	// Disable foreign key constraints to allow inserting external_releases without artist_settings
-	if _, err := db.Conn().Exec("PRAGMA foreign_keys = OFF"); err != nil {
-		t.Fatalf("disable foreign keys: %v", err)
-	}
-	// Re-enable foreign keys when we're done
-	defer func() {
-		if _, err := db.Conn().Exec("PRAGMA foreign_keys = ON"); err != nil {
-			t.Fatalf("re-enable foreign keys: %v", err)
-		}
-	}()
-
-	// Don't create artist settings - this will cause GetArtistSettings to return ErrArtistNotFound
-	// Insert external release directly to bypass FK constraint for testing inconsistent state
-	if _, err := db.Conn().Exec(
-		"INSERT INTO external_releases (rgid, artist_id, title, type, release_date, is_ignored) VALUES (?, ?, ?, ?, ?, ?)",
-		"rg1", "nonexistent-artist", "Test Album", "Album", "", false,
-	); err != nil {
-		t.Fatalf("insert external release: %v", err)
-	}
-
-	missing, err := ScanArtist(context.Background(), db, "nonexistent-artist", 0)
-	if err != nil {
-		t.Fatalf("ScanArtist() error: %v", err)
-	}
-
-	// Should return the release as missing (no filtering applied)
-	if len(missing) != 1 {
-		t.Errorf("expected 1 missing release, got %d", len(missing))
-	}
-	if missing[0].RGID != "rg1" {
-		t.Errorf("expected rg1 to be missing, got %v", missing[0].RGID)
-	}
-}
-
-// TestScanArtist_TypeToggle verifies that ScanArtist honors the artist's
-// ignore_singles / ignore_compilations toggles at read time, so a toggled
-// artist stops reporting those categories as missing immediately (without
-// waiting for the MusicBrainz cache to expire and prune rows on the next re-sync).
-func TestScanArtist_TypeToggle(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-
-	seedArtist(t, db, "a1", "Artist")
-	seedExternalRelease(t, db, "rg-album", "a1", "Album", false)
-	seedExternalRelease(t, db, "rg-single", "a1", "Single", false)
-	// seedExternalRelease leaves Type empty; set the primary type that the
-	// toggle filtering keys on.
-	if _, err := db.Conn().Exec("UPDATE external_releases SET type = ? WHERE rgid = ?", "Album", "rg-album"); err != nil {
-		t.Fatalf("set album type: %v", err)
-	}
-	if _, err := db.Conn().Exec("UPDATE external_releases SET type = ? WHERE rgid = ?", "Single", "rg-single"); err != nil {
-		t.Fatalf("set single type: %v", err)
-	}
-
-	// No toggle: both reported missing (no local albums).
-	got, err := ScanArtist(context.Background(), db, "a1", 0)
-	if err != nil {
-		t.Fatalf("ScanArtist error: %v", err)
-	}
-	if len(got) != 2 {
-		t.Fatalf("expected 2 missing before toggle, got %d", len(got))
-	}
-
-	// Toggle ignore_singles on.
-	if err := database.UpdateArtistSettings(db, "a1", map[string]interface{}{"ignore_singles": true}); err != nil {
-		t.Fatalf("toggle ignore_singles: %v", err)
-	}
-	got, err = ScanArtist(context.Background(), db, "a1", 0)
-	if err != nil {
-		t.Fatalf("ScanArtist error: %v", err)
-	}
-	if len(got) != 1 || got[0].RGID != "rg-album" {
-		ids := make([]string, len(got))
-		for i, m := range got {
-			ids[i] = m.RGID
-		}
-		t.Fatalf("expected only rg-album after toggle, got %v", ids)
-	}
-
-	// Toggle back off: single reappears.
-	if err := database.UpdateArtistSettings(db, "a1", map[string]interface{}{"ignore_singles": false}); err != nil {
-		t.Fatalf("toggle ignore_singles off: %v", err)
-	}
-	got, err = ScanArtist(context.Background(), db, "a1", 0)
-	if err != nil {
-		t.Fatalf("ScanArtist error: %v", err)
-	}
-	if len(got) != 2 {
-		t.Fatalf("expected 2 missing after toggle off, got %d", len(got))
-	}
-}
-
-// TestFilterConsistency_AcrossCacheStates verifies that filter behavior is consistent
-// across cache-hit (SyncArtistDiscography cache-hit path), cache-miss (FilterReleaseGroups),
-// and scanner (TypeFilter.suppressed) paths for releases with SecondaryTypes=["EP"]
-// when IgnoreSingles toggle is enabled.
-func TestFilterConsistency_AcrossCacheStates(t *testing.T) {
-	db := newTestDB(t)
-	defer db.Close()
-
-	// Seed artist settings with IgnoreSingles enabled
-	if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-		ID:                 "artist-1",
-		Name:               "Test Artist",
-		Monitored:          true,
-		IgnoreSingles:      true, // This is the key toggle we're testing
-		IgnoreCompilations: false,
-	}); err != nil {
-		t.Fatalf("SaveArtistSettings error: %v", err)
-	}
-
-	// Seed an external release with SecondaryTypes=["EP"] (should be treated as Single when IgnoreSingles=true)
-	if err := database.SaveExternalRelease(db, &database.ExternalRelease{
-		RGID:           "rg-ep-release",
-		ArtistID:       "artist-1",
-		Title:          "EP Release",
-		Type:           "Album", // Primary type is Album, but it has EP as secondary type
-		ReleaseDate:    "2024-01-01",
-		SecondaryTypes: []string{"EP"}, // This should make it count as a Single for filtering purposes
-		IsIgnored:      false,
-	}); err != nil {
-		t.Fatalf("SaveExternalRelease error: %v", err)
-	}
-
-	// Seed a local album (so we can test that the EP release is NOT missing when it should be filtered out)
-	if err := database.SaveLocalAlbum(db, &database.LocalAlbum{
-		ID:       "local-album-1",
-		ArtistID: "artist-1",
-		Title:    "Some Other Album", // Different title so it doesn't match the EP release
-	}); err != nil {
-		t.Fatalf("SaveLocalAlbum error: %v", err)
-	}
-
-	// Test 1: Cache-miss path (FilterReleaseGroups via musicbrainz package)
-	opts := musicbrainz.FilterOptions{
-		IgnoreSingles:      true,
-		IgnoreCompilations: false,
-	}
-	allReleases := []database.ExternalRelease{
-		{
-			RGID:           "rg-ep-release",
-			ArtistID:       "artist-1",
-			Title:          "EP Release",
-			Type:           "Album",
-			ReleaseDate:    "2024-01-01",
-			SecondaryTypes: []string{"EP"},
-			IsIgnored:      false,
-		},
-	}
-	filteredCacheMiss := musicbrainz.ApplyTypeToggles(allReleases, opts)
-	if len(filteredCacheMiss) != 0 {
-		t.Errorf("cache-miss path: expected EP release to be filtered out (treated as Single), got %d releases", len(filteredCacheMiss))
-	}
-
-	// Test 2: Scanner path (TypeFilter.suppressed via diff.go)
-	externalReleases, err := database.GetExternalReleasesByArtist(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetExternalReleasesByArtist error: %v", err)
-	}
-
-	// Get the artist settings to create the filter
-	settings, err := database.GetArtistSettings(db, "artist-1")
-	if err != nil {
-		t.Fatalf("GetArtistSettings error: %v", err)
-	}
-	filter := musicbrainz.FilterOptions{
-		IgnoreSingles:      settings.IgnoreSingles,
-		IgnoreCompilations: settings.IgnoreCompilations,
-	}
-
-	// Check if the EP release is suppressed by the scanner's filter
-	var isSuppressed bool
-	for _, ext := range externalReleases {
-		if ext.RGID == "rg-ep-release" {
-			isSuppressed = FilterIsSuppressed(filter, ext)
-			break
-		}
-	}
-	if !isSuppressed {
-		t.Errorf("scanner path: expected EP release to be suppressed (treated as Single), got not suppressed")
-	}
-
-	// Test 3: Conceptual cache-hit path verification
-	// The cache-hit path in SyncArtistDiscography uses the same ApplyTypeToggles function
-	// as the cache-miss path, so if they agree on the filtering logic, the cache-hit
-	// path will behave identically.
-	// We've already verified that both paths use the same underlying function:
-	// - Cache-miss: musicbrainz.ApplyTypeToggles (called directly in FilterReleaseGroups)
-	// - Cache-hit: musicbrainz.ApplyTypeToggles (called in SyncArtistDiscography cache-hit path)
-	// - Scanner: TypeFilter.suppressed which calls musicbrainz.ApplyTypeToggles internally
-	//
-	// Since all three paths ultimately use the same filtering function with the same
-	// inputs, they must produce identical results.
-}

internal/scanner/scanner.go

@@ -1,73 +0,0 @@
-// Package scanner implements the core fuzzy-diff engine of NaviWatcher.
-//
-// It compares a user's local albums (from Navidrome) against an artist's
-// external discography (from MusicBrainz) and reports the releases that are
-// present externally but have no sufficiently similar local album.
-package scanner
-
-import (
-	"unicode/utf8"
-
-	"github.com/lithammer/fuzzysearch/fuzzy"
-	"naviwatcher/internal/normalize"
-)
-
-// DefaultThreshold is the fallback similarity threshold used when a caller
-// passes threshold == 0. It matches config.Scanner.FuzzyThreshold default.
-const DefaultThreshold = 0.85
-
-// resolveThreshold returns the provided threshold, or DefaultThreshold when
-// the caller passes zero (unset). This keeps the engine usable when config
-// defaults are not threaded through explicitly.
-func resolveThreshold(threshold float64) float64 {
-	if threshold == 0 {
-		return DefaultThreshold
-	}
-	return threshold
-}
-
-// Similarity returns a normalized similarity score in the range [0.0, 1.0]
-// between two strings. The strings are normalized first (lowercased,
-// bracketed/parenthesized content and years stripped, special characters
-// removed), then compared with a Levenshtein-distance-based ratio.
-//
-// A score of 1.0 means the normalized strings are identical; 0.0 means they
-// share nothing. Empty strings (after normalization) always score 0.0.
-func Similarity(a, b string) float64 {
-	na := normalize.NormalizeString(a)
-	nb := normalize.NormalizeString(b)
-
-	// Two empty inputs are not considered a match.
-	if na == "" && nb == "" {
-		return 0.0
-	}
-	// One empty, one non-empty: no similarity.
-	if na == "" || nb == "" {
-		return 0.0
-	}
-
-	// fuzzy.LevenshteinDistance operates on runes, so the comparison basis
-	// must be rune count, not byte length, to avoid biasing the score for
-	// non-ASCII titles (where bytes > runes).
-	dist := fuzzy.LevenshteinDistance(na, nb)
-	maxLen := utf8.RuneCountInString(na)
-	if rb := utf8.RuneCountInString(nb); rb > maxLen {
-		maxLen = rb
-	}
-
-	// 1.0 - normalized distance → higher is more similar.
-	score := 1.0 - float64(dist)/float64(maxLen)
-	if score < 0.0 {
-		return 0.0
-	}
-	return score
-}
-
-// IsMatch reports whether a and b are similar enough to be considered the
-// same release, given the provided threshold in [0.0, 1.0]. A threshold of 0
-// (unset) falls back to DefaultThreshold, so this primitive honors the same
-// zero-means-default contract as FindMissingReleases/ScanArtist/ScanAll rather
-// than treating 0 as "always match".
-func IsMatch(a, b string, threshold float64) bool {
-	return Similarity(a, b) >= resolveThreshold(threshold)
-}

internal/scanner/scanner_test.go

@@ -1,322 +0,0 @@
-package scanner
-
-import (
-	"testing"
-
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/musicbrainz"
-)
-
-func TestSimilarity(t *testing.T) {
-	tests := []struct {
-		name    string
-		a       string
-		b       string
-		want    float64
-		epsilon float64
-	}{
-		{
-			name:    "exact match scores 1.0",
-			a:       "The Wall",
-			b:       "The Wall",
-			want:    1.0,
-			epsilon: 1e-9,
-		},
-		{
-			name:    "case-insensitive exact match scores 1.0",
-			a:       "The Wall",
-			b:       "the wall",
-			want:    1.0,
-			epsilon: 1e-9,
-		},
-		{
-			name:    "remastered variant stays above threshold",
-			a:       "The Wall",
-			b:       "The Wall (Remastered)",
-			want:    1.0, // parenthesized content is stripped during normalization
-			epsilon: 1e-9,
-		},
-		{
-			name: "year-suffixed variant stays above threshold",
-			a:    "Abbey Road",
-			b:    "Abbey Road (2019 Remix)",
-			// After normalization both collapse to "abbey road" → identical.
-			want:    1.0,
-			epsilon: 1e-9,
-		},
-		{
-			name:    "clearly different titles score low",
-			a:       "The Wall",
-			b:       "Completely Different Album",
-			want:    0.1538,
-			epsilon: 1e-3,
-		},
-		{
-			name:    "substring-ish title scores moderately below threshold",
-			a:       "Dark Side of the Moon",
-			b:       "Dark Side of the Moon Part II",
-			want:    0.7241,
-			epsilon: 1e-3,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := Similarity(tt.a, tt.b)
-			if diff := got - tt.want; diff > tt.epsilon || diff < -tt.epsilon {
-				t.Errorf("Similarity(%q, %q) = %v, want %v (+/- %v)", tt.a, tt.b, got, tt.want, tt.epsilon)
-			}
-			// Sanity: anything at/above the default threshold must be a match.
-			if got >= 0.85 && !IsMatch(tt.a, tt.b, 0) {
-				t.Errorf("Similarity(%q, %q) = %v >= 0.85 but IsMatch(...,0) is false", tt.a, tt.b, got)
-			}
-		})
-	}
-}
-
-func TestSimilarity_EmptyStrings(t *testing.T) {
-	// Both empty → no match (0.0).
-	if got := Similarity("", ""); got != 0.0 {
-		t.Errorf("Similarity(%q, %q) = %v, want 0.0", "", "", got)
-	}
-	// One empty, one non-empty → no similarity.
-	if got := Similarity("The Wall", ""); got != 0.0 {
-		t.Errorf("Similarity(%q, %q) = %v, want 0.0", "The Wall", "", got)
-	}
-	if got := Similarity("", "The Wall"); got != 0.0 {
-		t.Errorf("Similarity(%q, %q) = %v, want 0.0", "", "The Wall", got)
-	}
-	// Whitespace-only inputs normalize to empty → no match.
-	if got := Similarity("   ", "The Wall"); got != 0.0 {
-		t.Errorf("Similarity(%q, %q) = %v, want 0.0", "   ", "The Wall", got)
-	}
-}
-
-func TestIsMatch(t *testing.T) {
-	const threshold = 0.85
-
-	tests := []struct {
-		name     string
-		a        string
-		b        string
-		expected bool
-	}{
-		{name: "exact match is a match", a: "The Wall", b: "The Wall", expected: true},
-		{name: "remastered variant is a match", a: "The Wall", b: "The Wall (Remastered)", expected: true},
-		{name: "year variant is a match", a: "Abbey Road", b: "Abbey Road (2019)", expected: true},
-		{name: "clearly different is not a match", a: "The Wall", b: "Random Noise", expected: false},
-		{name: "empty vs non-empty is not a match", a: "", b: "The Wall", expected: false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := IsMatch(tt.a, tt.b, threshold); got != tt.expected {
-				t.Errorf("IsMatch(%q, %q, %v) = %v, want %v", tt.a, tt.b, threshold, got, tt.expected)
-			}
-		})
-	}
-}
-
-func TestFindMissingReleases(t *testing.T) {
-	const threshold = 0.85
-
-	artistA := "artist-a"
-	artistB := "artist-b"
-
-	tests := []struct {
-		name     string
-		local    []database.LocalAlbum
-		external []database.ExternalRelease
-		want     []string // RGIDs expected to be reported as missing
-	}{
-		{
-			name:  "no local albums means all external are missing",
-			local: nil,
-			external: []database.ExternalRelease{
-				{RGID: "rg1", ArtistID: artistA, Title: "The Wall"},
-				{RGID: "rg2", ArtistID: artistA, Title: "Animals"},
-			},
-			want: []string{"rg1", "rg2"},
-		},
-		{
-			name: "exact local title is not missing",
-			local: []database.LocalAlbum{
-				{ID: "l1", ArtistID: artistA, Title: "The Wall"},
-			},
-			external: []database.ExternalRelease{
-				{RGID: "rg1", ArtistID: artistA, Title: "The Wall"},
-				{RGID: "rg2", ArtistID: artistA, Title: "Animals"},
-			},
-			want: []string{"rg2"},
-		},
-		{
-			name: "fuzzy local title (remastered) is not missing",
-			local: []database.LocalAlbum{
-				{ID: "l1", ArtistID: artistA, Title: "The Wall (Remastered)"},
-			},
-			external: []database.ExternalRelease{
-				{RGID: "rg1", ArtistID: artistA, Title: "The Wall"},
-				{RGID: "rg2", ArtistID: artistA, Title: "Animals"},
-			},
-			want: []string{"rg2"},
-		},
-		{
-			name: "ignored external is never reported",
-			local: []database.LocalAlbum{
-				{ID: "l1", ArtistID: artistA, Title: "The Wall"},
-			},
-			external: []database.ExternalRelease{
-				{RGID: "rg1", ArtistID: artistA, Title: "The Wall"},
-				{RGID: "rg2", ArtistID: artistA, Title: "Animals", IsIgnored: true},
-			},
-			want: []string{},
-		},
-		{
-			name: "different artist id is not matched across artists",
-			local: []database.LocalAlbum{
-				{ID: "l1", ArtistID: artistA, Title: "The Wall"},
-			},
-			external: []database.ExternalRelease{
-				{RGID: "rg1", ArtistID: artistB, Title: "The Wall"},
-			},
-			want: []string{"rg1"},
-		},
-		{
-			name: "threshold boundary at 0.85",
-			local: []database.LocalAlbum{
-				{ID: "l1", ArtistID: artistA, Title: "The Wall Live"},
-			},
-			external: []database.ExternalRelease{
-				{RGID: "rg1", ArtistID: artistA, Title: "The Wall"},
-			},
-			want: []string{"rg1"}, // "The Wall Live" vs "The Wall" is below 0.85
-		},
-		{
-			name: "empty external list returns nothing",
-			local: []database.LocalAlbum{
-				{ID: "l1", ArtistID: artistA, Title: "The Wall"},
-			},
-			external: nil,
-			want:     []string{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := FindMissingReleases(tt.local, tt.external, threshold, musicbrainz.FilterOptions{})
-
-			gotRGIDs := make([]string, 0, len(got))
-			for _, m := range got {
-				gotRGIDs = append(gotRGIDs, m.RGID)
-			}
-
-			if len(gotRGIDs) != len(tt.want) {
-				t.Fatalf("FindMissingReleases() returned %v, want RGIDs %v", gotRGIDs, tt.want)
-			}
-			wantSet := make(map[string]struct{}, len(tt.want))
-			for _, r := range tt.want {
-				wantSet[r] = struct{}{}
-			}
-			for _, r := range gotRGIDs {
-				if _, ok := wantSet[r]; !ok {
-					t.Errorf("FindMissingReleases() returned unexpected RGID %q (got %v, want %v)", r, gotRGIDs, tt.want)
-				}
-			}
-		})
-	}
-}
-
-func TestFindMissingReleases_FilterOptions(t *testing.T) {
-	const threshold = 0.85
-	artist := "artist-a"
-
-	external := []database.ExternalRelease{
-		{RGID: "rg-album", ArtistID: artist, Title: "The Wall", Type: "Album"},
-		{RGID: "rg-single", ArtistID: artist, Title: "B-side", Type: "Single"},
-		{RGID: "rg-comp", ArtistID: artist, Title: "Hits", Type: "Compilation"},
-		{RGID: "rg-comp-sec", ArtistID: artist, Title: "Live at X", Type: "Album", SecondaryTypes: []string{"Compilation"}},
-	}
-
-	tests := []struct {
-		name   string
-		filter musicbrainz.FilterOptions
-		want   []string
-	}{
-		{
-			name:   "no filter reports all",
-			filter: musicbrainz.FilterOptions{},
-			want:   []string{"rg-album", "rg-single", "rg-comp", "rg-comp-sec"},
-		},
-		{
-			name:   "ignore singles drops Single primary type",
-			filter: musicbrainz.FilterOptions{IgnoreSingles: true},
-			want:   []string{"rg-album", "rg-comp", "rg-comp-sec"},
-		},
-		{
-			name:   "ignore compilations drops Compilation primary and secondary type",
-			filter: musicbrainz.FilterOptions{IgnoreCompilations: true},
-			want:   []string{"rg-album", "rg-single"},
-		},
-		{
-			name:   "both toggles drop singles and compilations",
-			filter: musicbrainz.FilterOptions{IgnoreSingles: true, IgnoreCompilations: true},
-			want:   []string{"rg-album"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := FindMissingReleases(nil, external, threshold, tt.filter)
-			gotRGIDs := make([]string, 0, len(got))
-			for _, m := range got {
-				gotRGIDs = append(gotRGIDs, m.RGID)
-			}
-			wantSet := make(map[string]struct{}, len(tt.want))
-			for _, r := range tt.want {
-				wantSet[r] = struct{}{}
-			}
-			if len(gotRGIDs) != len(tt.want) {
-				t.Fatalf("got %v, want %v", gotRGIDs, tt.want)
-			}
-			for _, r := range gotRGIDs {
-				if _, ok := wantSet[r]; !ok {
-					t.Errorf("unexpected RGID %q", r)
-				}
-			}
-		})
-	}
-}
-
-func TestFindMissingReleases_ThresholdBoundaryInclusive(t *testing.T) {
-	// A title at exactly the threshold must NOT be reported as missing
-	// (IsMatch uses >= threshold).
-	local := []database.LocalAlbum{
-		{ID: "l1", ArtistID: "a", Title: "The Wall Live"},
-	}
-	// Force a known score: "the wall" vs "the wall" would be 1.0; instead
-	// use a release whose similarity is exactly 0.85 so the boundary is hit.
-	// We assert behaviour via the documented contract using IsMatch, not a
-	// brittle exact score here.
-	external := []database.ExternalRelease{
-		{RGID: "rg1", ArtistID: "a", Title: "The Wall"},
-	}
-	// With default threshold 0.85, "The Wall Live" does not match "The Wall";
-	// at a low threshold it would. Confirms threshold is honoured.
-	if len(FindMissingReleases(local, external, 0.85, musicbrainz.FilterOptions{})) != 1 {
-		t.Errorf("expected 1 missing at 0.85 threshold")
-	}
-}
-
-func TestIsMatch_ThresholdBoundary(t *testing.T) {
-	// A moderately different title should be a match at a low threshold but
-	// not at a high one, confirming the boundary is inclusive (>=).
-	a, b := "The Wall", "The Wall Live"
-	low := IsMatch(a, b, 0.5)
-	high := IsMatch(a, b, 0.99)
-	if !low {
-		t.Errorf("IsMatch(%q, %q, 0.5) = false, want true", a, b)
-	}
-	if high {
-		t.Errorf("IsMatch(%q, %q, 0.99) = true, want false", a, b)
-	}
-}

internal/web/handlers.go

@@ -1,422 +0,0 @@
-package web
-
-import (
-	"context"
-	"embed"
-	"errors"
-	"fmt"
-	"html/template"
-	"net/http"
-	"regexp"
-
-	"naviwatcher/internal/config"
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/scanner"
-)
-
-// idPattern bounds the {id} path segment accepted by artist routes. Artist IDs
-// come from Navidrome (numeric/UUID) and MusicBrainz (UUID), so word
-// characters and hyphens cover every legitimate value. Rejecting anything else
-// prevents a crafted id (containing "/", control characters, or whitespace)
-// from breaking route matching or being reflected into a Location header.
-var idPattern = regexp.MustCompile(`^[\w-]+$`)
-
-// isValidID reports whether s is a safe artist-ID path segment.
-func isValidID(s string) bool {
-	return idPattern.MatchString(s)
-}
-
-//go:embed templates/*.html
-var templates embed.FS
-
-// dashboardTmpl and the other page templates are parsed once at package init
-// from the embedded templates.
-var (
-	dashboardTmpl = template.Must(template.ParseFS(templates, "templates/dashboard.html"))
-	artistTmpl    = template.Must(template.ParseFS(templates, "templates/artist.html"))
-	archiveTmpl   = template.Must(template.ParseFS(templates, "templates/archive.html"))
-)
-
-// handleDashboard renders the artist dashboard: monitored artists with their
-// missing-release counts.
-func (s *Server) handleDashboard(w http.ResponseWriter, r *http.Request) {
-	// Only serve the index at "/" (and not e.g. "/favicon.ico" fallthroughs).
-	if r.URL.Path != "/" {
-		http.NotFound(w, r)
-		return
-	}
-
-	threshold := s.threshold
-	data, err := s.buildDashboardData(r.Context(), threshold)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("failed to build dashboard: %v", err), http.StatusInternalServerError)
-		return
-	}
-
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	if err := dashboardTmpl.Execute(w, data); err != nil {
-		http.Error(w, fmt.Sprintf("template render error: %v", err), http.StatusInternalServerError)
-	}
-}
-
-// LocalAlbumView is the projection of a local album for the artist detail page.
-type LocalAlbumView struct {
-	Title string
-}
-
-// MissingReleaseView is the projection of a missing external release for the
-// artist detail page, including the ignore toggle form target.
-type MissingReleaseView struct {
-	ArtistID    string
-	ArtistName  string
-	RGID        string
-	Title       string
-	Type        string
-	ReleaseDate string
-	Ignored     bool
-}
-
-// ArtistData is the view model for the artist detail page.
-type ArtistData struct {
-	ID            string
-	Name          string
-	MBID          string
-	IgnoreSingles bool
-	IgnoreCompilations bool
-	IgnoreLive    bool
-	IgnoreRemix   bool
-	LocalAlbums   []LocalAlbumView
-	Missing       []MissingReleaseView
-	UIBaseURL     string
-}
-
-// handleArtist renders the detail page for a single artist: local albums
-// (Subsonic) plus the externally-found missing releases (MB cache) with ignore
-// buttons.
-func (s *Server) handleArtist(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodGet {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-
-	// The enhanced ServeMux extracts the {id} path segment for us.
-	id := r.PathValue("id")
-	if id == "" || !isValidID(id) {
-		http.NotFound(w, r)
-		return
-	}
-
-	data, err := s.buildArtistData(r.Context(), id)
-	if err != nil {
-		if err == database.ErrArtistNotFound {
-			http.NotFound(w, r)
-			return
-		}
-		http.Error(w, fmt.Sprintf("failed to build artist page: %v", err), http.StatusInternalServerError)
-		return
-	}
-
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	if err := artistTmpl.Execute(w, data); err != nil {
-		http.Error(w, fmt.Sprintf("template render error: %v", err), http.StatusInternalServerError)
-	}
-}
-
-// buildArtistData computes the artist detail view model: the artist's settings,
-// local albums (Subsonic), and missing external releases (MB cache).
-func (s *Server) buildArtistData(ctx context.Context, id string) (*ArtistData, error) {
-	settings, err := database.GetArtistSettings(s.db, id)
-	if err != nil {
-		if err == database.ErrArtistNotFound {
-			return nil, database.ErrArtistNotFound
-		}
-		return nil, fmt.Errorf("load artist settings: %w", err)
-	}
-
-	locals, err := database.GetLocalAlbumsByArtist(s.db, id)
-	if err != nil {
-		return nil, fmt.Errorf("load local albums: %w", err)
-	}
-
-	// Compute the missing releases for this single artist (ScanArtist scopes the
-	// query to the artist instead of scanning every monitored artist). ScanAll
-	// excludes ignored releases, so every missing release surfaced here is, by
-	// definition, not ignored.
-	threshold := s.threshold
-	missing, err := scanner.ScanArtist(ctx, s.db, id, threshold)
-	if err != nil {
-		return nil, fmt.Errorf("scan artist: %w", err)
-	}
-
-	data := &ArtistData{
-		ID:                 settings.ID,
-		Name:               settings.Name,
-		MBID:               settings.MBID,
-		IgnoreSingles:      settings.IgnoreSingles,
-		IgnoreCompilations: settings.IgnoreCompilations,
-		IgnoreLive:         settings.IgnoreLive,
-		IgnoreRemix:        settings.IgnoreRemix,
-		UIBaseURL:          s.uiBaseURL,
-	}
-	for _, a := range locals {
-		data.LocalAlbums = append(data.LocalAlbums, LocalAlbumView{Title: a.Title})
-	}
-	for _, m := range missing {
-		data.Missing = append(data.Missing, MissingReleaseView{
-			ArtistID:    m.ArtistID,
-			RGID:        m.RGID,
-			Title:       m.Title,
-			Type:        m.Type,
-			ReleaseDate: m.ReleaseDate,
-			Ignored:     false,
-		})
-	}
-	return data, nil
-}
-
-// ArchiveData is the view model for the ignored-releases archive page.
-type ArchiveData struct {
-	Releases  []MissingReleaseView
-	UIBaseURL string
-}
-
-// handleArchive renders the archive of previously-ignored releases with restore
-// actions.
-func (s *Server) handleArchive(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodGet {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-
-	ignored, err := database.GetIgnoredReleases(s.db)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("failed to load archive: %v", err), http.StatusInternalServerError)
-		return
-	}
-
-	data := &ArchiveData{UIBaseURL: s.uiBaseURL}
-	for _, rel := range ignored {
-		view := MissingReleaseView{
-			ArtistID:    rel.ArtistID,
-			RGID:        rel.RGID,
-			Title:       rel.Title,
-			Type:        rel.Type,
-			ReleaseDate: rel.ReleaseDate,
-			Ignored:     true,
-		}
-		if settings, err := database.GetArtistSettings(s.db, rel.ArtistID); err == nil {
-			view.ArtistName = settings.Name
-		}
-		data.Releases = append(data.Releases, view)
-	}
-
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	if err := archiveTmpl.Execute(w, data); err != nil {
-		http.Error(w, fmt.Sprintf("template render error: %v", err), http.StatusInternalServerError)
-	}
-}
-
-// NewServerWithConfig is a convenience constructor that accepts the full
-// *config.Config (mirroring how the app constructs other components). It
-// forwards the server sub-config and derives uiBaseURL from the configured
-// public_url, falling back to a best-effort host:port.
-// ResolveUIBaseURL derives the externally-reachable base URL of the Web UI from
-// config. An explicit public_url (e.g. behind a reverse proxy) is preferred.
-// When unset, it falls back to http://host:port — unless the bind host is the
-// unspecified "0.0.0.0" (not reachable from outside the host), in which case an
-// empty string is returned so callers omit the link rather than advertise an
-// unusable address. The same derivation is used by both the Web UI and the
-// Telegram notifier so dashboard links are consistent across surfaces.
-func ResolveUIBaseURL(cfg *config.ServerConfig) string {
-	base := cfg.PublicURL
-	if base == "" && cfg.Host != "0.0.0.0" && cfg.Host != "" {
-		base = fmt.Sprintf("http://%s:%d", cfg.Host, cfg.Port)
-	}
-	return base
-}
-
-func NewServerWithConfig(cfg *config.Config, db *database.DB) *Server {
-	// Prefer an explicit, externally-reachable public_url (e.g. behind a
-	// reverse proxy). Fall back to host:port — but if the bind host is the
-	// unspecified "0.0.0.0", it is not reachable from outside the host, so
-	// omit the link rather than advertise an unusable address.
-	base := ResolveUIBaseURL(&cfg.Server)
-	return NewServer(&cfg.Server, db, base, cfg.Scanner.FuzzyThreshold)
-}
-
-// ignoreOrRestore handles the POST /artist/{id}/ignore and .../restore routes.
-func (s *Server) ignoreOrRestore(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	if !s.sameOrigin(r) {
-		http.Error(w, "forbidden: cross-origin request", http.StatusForbidden)
-		return
-	}
-	id := r.PathValue("id")
-	if id == "" || !isValidID(id) {
-		http.NotFound(w, r)
-		return
-	}
-
-	// The route path determines the action.
-	action := "ignore"
-	switch r.URL.Path {
-	case "/artist/" + id + "/restore":
-		action = "restore"
-	}
-
-	if err := r.ParseForm(); err != nil {
-		http.Error(w, "bad form", http.StatusBadRequest)
-		return
-	}
-	rgid := r.FormValue("rgid")
-	if rgid == "" {
-		http.Error(w, "missing rgid", http.StatusBadRequest)
-		return
-	}
-
-	ignored := action == "ignore"
-	if err := database.SetReleaseIgnored(s.db, rgid, ignored); err != nil {
-		// A 0-rows-affected error means the release was already removed by a
-		// concurrent re-sync (it disappeared from MusicBrainz). That is benign:
-		// redirect back rather than surfacing a 500 for a now-nonexistent row.
-		if errors.Is(err, database.ErrReleaseNotFound) {
-			http.Redirect(w, r, "/artist/"+id, http.StatusSeeOther)
-			return
-		}
-		http.Error(w, fmt.Sprintf("failed to set ignored: %v", err), http.StatusInternalServerError)
-		return
-	}
-
-	http.Redirect(w, r, "/artist/"+id, http.StatusSeeOther)
-}
-
-// toggleIgnoreSingles handles POST /artist/{id}/ignore-singles which flips the
-// artist's ignore_singles flag.
-func (s *Server) toggleIgnoreSingles(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	if !s.sameOrigin(r) {
-		http.Error(w, "forbidden: cross-origin request", http.StatusForbidden)
-		return
-	}
-	id := r.PathValue("id")
-	if id == "" || !isValidID(id) {
-		http.NotFound(w, r)
-		return
-	}
-
-	settings, err := database.GetArtistSettings(s.db, id)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("load artist: %v", err), http.StatusInternalServerError)
-		return
-	}
-	if err := database.UpdateArtistSettings(s.db, id, map[string]interface{}{
-		"ignore_singles": !settings.IgnoreSingles,
-	}); err != nil {
-		http.Error(w, fmt.Sprintf("update artist: %v", err), http.StatusInternalServerError)
-		return
-	}
-
-	http.Redirect(w, r, "/artist/"+id, http.StatusSeeOther)
-}
-
-// toggleIgnoreCompilations handles POST /artist/{id}/ignore-compilations which flips the
-// artist's ignore_compilations flag.
-func (s *Server) toggleIgnoreCompilations(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	if !s.sameOrigin(r) {
-		http.Error(w, "forbidden: cross-origin request", http.StatusForbidden)
-		return
-	}
-	id := r.PathValue("id")
-	if id == "" || !isValidID(id) {
-		http.NotFound(w, r)
-		return
-	}
-
-	settings, err := database.GetArtistSettings(s.db, id)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("load artist: %v", err), http.StatusInternalServerError)
-		return
-	}
-	if err := database.UpdateArtistSettings(s.db, id, map[string]interface{}{
-		"ignore_compilations": !settings.IgnoreCompilations,
-	}); err != nil {
-		http.Error(w, fmt.Sprintf("update artist: %v", err), http.StatusInternalServerError)
-		return
-	}
-
-	http.Redirect(w, r, "/artist/"+id, http.StatusSeeOther)
-}
-
-// toggleIgnoreLive handles POST /artist/{id}/ignore-live which flips the
-// artist's ignore_live flag.
-func (s *Server) toggleIgnoreLive(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	if !s.sameOrigin(r) {
-		http.Error(w, "forbidden: cross-origin request", http.StatusForbidden)
-		return
-	}
-	id := r.PathValue("id")
-	if id == "" || !isValidID(id) {
-		http.NotFound(w, r)
-		return
-	}
-
-	settings, err := database.GetArtistSettings(s.db, id)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("load artist: %v", err), http.StatusInternalServerError)
-		return
-	}
-	if err := database.UpdateArtistSettings(s.db, id, map[string]interface{}{
-		"ignore_live": !settings.IgnoreLive,
-	}); err != nil {
-		http.Error(w, fmt.Sprintf("update artist: %v", err), http.StatusInternalServerError)
-		return
-	}
-
-	http.Redirect(w, r, "/artist/"+id, http.StatusSeeOther)
-}
-
-// toggleIgnoreRemix handles POST /artist/{id}/ignore-remix which flips the
-// artist's ignore_remix flag.
-func (s *Server) toggleIgnoreRemix(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	if !s.sameOrigin(r) {
-		http.Error(w, "forbidden: cross-origin request", http.StatusForbidden)
-		return
-	}
-	id := r.PathValue("id")
-	if id == "" || !isValidID(id) {
-		http.NotFound(w, r)
-		return
-	}
-
-	settings, err := database.GetArtistSettings(s.db, id)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("load artist: %v", err), http.StatusInternalServerError)
-		return
-	}
-	if err := database.UpdateArtistSettings(s.db, id, map[string]interface{}{
-		"ignore_remix": !settings.IgnoreRemix,
-	}); err != nil {
-		http.Error(w, fmt.Sprintf("update artist: %v", err), http.StatusInternalServerError)
-		return
-	}
-
-	http.Redirect(w, r, "/artist/"+id, http.StatusSeeOther)
-}

internal/web/server.go

@@ -1,227 +0,0 @@
-// Package web implements the NaviWatcher HTTP dashboard: a net/http server with
-// embedded templates, basic-auth protection, and a dashboard that lists
-// monitored artists with their missing-release counts.
-package web
-
-import (
-	"context"
-	"crypto/subtle"
-	"encoding/base64"
-	"fmt"
-	"log"
-	"net/http"
-	"net/url"
-	"strings"
-	"time"
-
-	"naviwatcher/internal/config"
-	"naviwatcher/internal/database"
-	"naviwatcher/internal/scanner"
-)
-
-// Server is the NaviWatcher web dashboard HTTP server.
-type Server struct {
-	cfg *config.ServerConfig
-	db  *database.DB
-	mux *http.ServeMux
-
-	// uiBaseURL is the externally reachable base URL of the dashboard (scheme +
-	// host), used to build links in notifications and elsewhere. Optional.
-	uiBaseURL string
-
-	// threshold is the fuzzy-similarity cutoff used when scanning for missing
-	// releases; 0 means use the scanner default.
-	threshold float64
-}
-
-// NewServer constructs a dashboard Server bound to the given DB and server
-// config. uiBaseURL is the externally reachable origin (e.g.
-// "http://localhost:8080") used when rendering absolute links; pass "" to omit.
-// threshold is the fuzzy-similarity cutoff (0 → scanner default).
-func NewServer(cfg *config.ServerConfig, db *database.DB, uiBaseURL string, threshold float64) *Server {
-	s := &Server{
-		cfg:       cfg,
-		db:        db,
-		uiBaseURL: strings.TrimRight(uiBaseURL, "/"),
-		threshold: threshold,
-	}
-	// Warn loudly when auth is disabled but the server is reachable from outside
-	// the host: Basic auth is silently skipped when Username/Password are empty,
-	// so an operator who forgets credentials on a non-loopback bind would expose
-	// DB-mutating POST routes (ignore/restore/toggle) to the network.
-	if (cfg.Username == "" || cfg.Password == "") && cfg.Host != "localhost" && cfg.Host != "127.0.0.1" && cfg.Host != "::1" {
-		log.Printf("WARNING: Web UI authentication is DISABLED (server.username/password empty) and the server is bound to %q. The dashboard and its state-changing routes are exposed to the network. Set credentials or bind to localhost.", cfg.Host)
-	}
-	mux := http.NewServeMux()
-	mux.HandleFunc("/", s.handleDashboard)
-	mux.HandleFunc("/artist/{id}", s.handleArtist)
-	mux.HandleFunc("/artist/{id}/ignore", s.ignoreOrRestore)
-	mux.HandleFunc("/artist/{id}/restore", s.ignoreOrRestore)
-	mux.HandleFunc("/artist/{id}/ignore-singles", s.toggleIgnoreSingles)
-	mux.HandleFunc("/artist/{id}/ignore-compilations", s.toggleIgnoreCompilations)
-	mux.HandleFunc("/artist/{id}/ignore-live", s.toggleIgnoreLive)
-	mux.HandleFunc("/artist/{id}/ignore-remix", s.toggleIgnoreRemix)
-	mux.HandleFunc("/archive", s.handleArchive)
-	s.mux = mux
-	return s
-}
-
-// Handler returns the http.Handler (auth-wrapped mux) for the server. It is
-// exported so callers can embed the dashboard in a larger handler tree or test
-// it directly via httptest.
-func (s *Server) Handler() http.Handler {
-	return s.authMiddleware(s.mux)
-}
-
-// Addr returns the listen address ("host:port") for this server.
-func (s *Server) Addr() string {
-	return fmt.Sprintf("%s:%d", s.cfg.Host, s.cfg.Port)
-}
-
-// Start begins listening and serving until the context is cancelled, then shuts
-// down gracefully. It returns any unrecoverable serve error (a clean shutdown
-// due to ctx cancellation returns nil).
-func (s *Server) Start(ctx context.Context) error {
-	srv := &http.Server{
-		Addr:              s.Addr(),
-		Handler:           s.Handler(),
-		ReadTimeout:       15 * time.Second,
-		ReadHeaderTimeout: 10 * time.Second,
-		WriteTimeout:      30 * time.Second,
-		IdleTimeout:       120 * time.Second,
-	}
-
-	go func() {
-		<-ctx.Done()
-		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-		if err := srv.Shutdown(shutdownCtx); err != nil {
-			log.Printf("web server shutdown error: %v", err)
-		}
-	}()
-
-	log.Printf("Web UI listening on %s", s.Addr())
-	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-		return fmt.Errorf("web server serve: %w", err)
-	}
-	return nil
-}
-
-// authMiddleware enforces HTTP Basic auth per RFC 7617 using a constant-time
-// comparison of the base64-encoded "user:pass" credential. When either
-// Username or Password is empty, auth is disabled (useful for local/dev).
-func (s *Server) authMiddleware(next http.Handler) http.Handler {
-	user := s.cfg.Username
-	pass := s.cfg.Password
-	if user == "" || pass == "" {
-		return next
-	}
-
-	// Precompute the expected Authorization header value once.
-	want := "Basic " + base64.StdEncoding.EncodeToString([]byte(user+":"+pass))
-
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		header := r.Header.Get("Authorization")
-		if header == "" {
-			unauthorized(w)
-			return
-		}
-		// Constant-time compare of the full header value.
-		if subtle.ConstantTimeCompare([]byte(header), []byte(want)) != 1 {
-			unauthorized(w)
-			return
-		}
-		next.ServeHTTP(w, r)
-	})
-}
-
-// unauthorized writes a 401 with a Basic auth challenge.
-func unauthorized(w http.ResponseWriter) {
-	w.Header().Set("WWW-Authenticate", `Basic realm="NaviWatcher"`)
-	w.WriteHeader(http.StatusUnauthorized)
-	_, _ = w.Write([]byte("401 Unauthorized\n"))
-}
-
-// sameOrigin returns true when the request's Origin (or, lacking that, Referer)
-// header matches the server's own origin. State-changing POST routes use this
-// as a lightweight CSRF defense: a cross-site request from a logged-in
-// operator's browser will carry a different Origin/Referer and be rejected.
-// When the header is absent (e.g. a same-origin form POST from older browsers
-// or curl), the request is allowed rather than blocked, since the dashboard
-// only ever issues same-origin form posts.
-func (s *Server) sameOrigin(r *http.Request) bool {
-	origin := r.Header.Get("Origin")
-	if origin == "" {
-		origin = r.Header.Get("Referer")
-	}
-	if origin == "" {
-		return true
-	}
-	got, err := url.Parse(origin)
-	if err != nil || got.Host == "" {
-		return false
-	}
-	// Accept the actual Host the client reached (covers 0.0.0.0 bind with
-	// localhost/127.0.0.1 access) as well as the configured bind address.
-	gotHost := got.Host
-	reqHost := r.Host
-	if reqHost == "" {
-		reqHost = s.Addr()
-	}
-	return gotHost == reqHost || gotHost == s.Addr()
-}
-
-// ArtistSummary is the dashboard projection of a single monitored artist and
-// its missing-release count.
-type ArtistSummary struct {
-	ID           string
-	Name         string
-	MBID         string
-	MissingCount int
-	Monitored    bool
-}
-
-// DashboardData is the view model passed to the dashboard template.
-type DashboardData struct {
-	Artists []ArtistSummary
-	// TotalMissing is the sum of all artists' missing counts.
-	TotalMissing int
-	// UIBaseURL is the externally reachable origin, for building links.
-	UIBaseURL string
-}
-
-// buildDashboardData computes the dashboard view model: every monitored artist
-// joined with its current missing-release count (from the scanner).
-func (s *Server) buildDashboardData(ctx context.Context, threshold float64) (*DashboardData, error) {
-	settings, err := database.GetAllArtistSettings(s.db)
-	if err != nil {
-		return nil, fmt.Errorf("load artist settings: %w", err)
-	}
-
-	// Compute missing releases once and group by artist.
-	missing, err := scanner.ScanAll(ctx, s.db, threshold)
-	if err != nil {
-		return nil, fmt.Errorf("scan: %w", err)
-	}
-	missingByArtist := make(map[string]int)
-	for _, m := range missing {
-		missingByArtist[m.ArtistID]++
-	}
-
-	data := &DashboardData{UIBaseURL: s.uiBaseURL}
-	for _, a := range settings {
-		if !a.Monitored {
-			continue
-		}
-		count := missingByArtist[a.ID]
-		data.Artists = append(data.Artists, ArtistSummary{
-			ID:           a.ID,
-			Name:         a.Name,
-			MBID:         a.MBID,
-			MissingCount: count,
-			Monitored:    true,
-		})
-		data.TotalMissing += count
-	}
-	return data, nil
-}

internal/web/server_test.go

@@ -1,549 +0,0 @@
-package web
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"naviwatcher/internal/config"
-	"naviwatcher/internal/database"
-)
-
-// seedArtist inserts an artist_settings row and returns its ID.
-func seedArtist(t *testing.T, db *database.DB, id, name, mbid string, monitored bool) {
-	t.Helper()
-	if err := database.SaveArtistSettings(db, &database.ArtistSettings{
-		ID:        id,
-		Name:      name,
-		MBID:      mbid,
-		Monitored: monitored,
-	}); err != nil {
-		t.Fatalf("seed artist %s: %v", id, err)
-	}
-}
-
-// seedLocalAlbum inserts a local_albums row.
-func seedLocalAlbum(t *testing.T, db *database.DB, id, artistID, title string) {
-	t.Helper()
-	if err := database.SaveLocalAlbum(db, &database.LocalAlbum{ID: id, ArtistID: artistID, Title: title}); err != nil {
-		t.Fatalf("seed local album %s: %v", id, err)
-	}
-}
-
-// seedExternalRelease inserts an external_releases row (not ignored).
-func seedExternalRelease(t *testing.T, db *database.DB, rgid, artistID, title string) {
-	t.Helper()
-	if err := database.SaveExternalRelease(db, &database.ExternalRelease{
-		RGID:     rgid,
-		ArtistID: artistID,
-		Title:    title,
-	}); err != nil {
-		t.Fatalf("seed external release %s: %v", rgid, err)
-	}
-}
-
-func newServer(t *testing.T, user, pass string) (*Server, *database.DB) {
-	t.Helper()
-	db, err := database.New(":memory:")
-	if err != nil {
-		t.Fatalf("open db: %v", err)
-	}
-	cfg := &config.ServerConfig{Host: "0.0.0.0", Port: 8080, Username: user, Password: pass}
-	s := NewServer(cfg, db, "http://ui.example", 0)
-	return s, db
-}
-
-func TestDashboard_Authenticated200(t *testing.T) {
-	s, db := newServer(t, "admin", "secret")
-	seedArtist(t, db, "a1", "Radiohead", "mbid-1", true)
-	seedLocalAlbum(t, db, "l1", "a1", "OK Computer")
-	// One missing release (no local album matches "Kid A").
-	seedExternalRelease(t, db, "r1", "a1", "Kid A")
-
-	req := httptest.NewRequest(http.MethodGet, "/", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", rec.Code)
-	}
-	body := rec.Body.String()
-	if !strings.Contains(body, "Radiohead") {
-		t.Errorf("expected artist name in body, got:\n%s", body)
-	}
-	if !strings.Contains(body, "1") {
-		t.Errorf("expected missing count rendered, got:\n%s", body)
-	}
-	if !strings.Contains(body, "mbid-1") {
-		t.Errorf("expected MBID rendered, got:\n%s", body)
-	}
-	// The dashboard must link each artist to its detail page, otherwise the
-	// ignore/restore/singles actions on that page are unreachable via normal UI
-	// navigation.
-	if !strings.Contains(body, `href="/artist/a1"`) {
-		t.Errorf("expected link to artist detail page, got:\n%s", body)
-	}
-}
-
-func TestDashboard_Unauthenticated401(t *testing.T) {
-	s, _ := newServer(t, "admin", "secret")
-
-	req := httptest.NewRequest(http.MethodGet, "/", nil)
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("expected 401, got %d", rec.Code)
-	}
-	if !strings.Contains(rec.Header().Get("WWW-Authenticate"), "Basic") {
-		t.Errorf("expected Basic auth challenge, got headers: %v", rec.Header())
-	}
-}
-
-func TestDashboard_WrongPassword401(t *testing.T) {
-	s, _ := newServer(t, "admin", "secret")
-
-	req := httptest.NewRequest(http.MethodGet, "/", nil)
-	req.SetBasicAuth("admin", "wrong")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("expected 401 for wrong password, got %d", rec.Code)
-	}
-}
-
-func TestDashboard_NoAuthWhenDisabled(t *testing.T) {
-	// When username or password is empty, auth is bypassed.
-	s, db := newServer(t, "", "")
-	seedArtist(t, db, "a1", "Boards of Canada", "", true)
-
-	req := httptest.NewRequest(http.MethodGet, "/", nil)
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200 when auth disabled, got %d", rec.Code)
-	}
-	if !strings.Contains(rec.Body.String(), "Boards of Canada") {
-		t.Errorf("expected artist rendered, got:\n%s", rec.Body.String())
-	}
-}
-
-func TestDashboard_SkipsUnmonitored(t *testing.T) {
-	s, db := newServer(t, "admin", "secret")
-	seedArtist(t, db, "mon", "Monitored Artist", "", true)
-	seedArtist(t, db, "unmon", "Unmonitored Artist", "", false)
-	seedExternalRelease(t, db, "r1", "unmon", "Should not appear")
-	seedExternalRelease(t, db, "r2", "mon", "Missing here")
-
-	req := httptest.NewRequest(http.MethodGet, "/", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", rec.Code)
-	}
-	body := rec.Body.String()
-	if strings.Contains(body, "Unmonitored Artist") {
-		t.Errorf("unmonitored artist should not appear, got:\n%s", body)
-	}
-	if !strings.Contains(body, "Monitored Artist") {
-		t.Errorf("monitored artist should appear, got:\n%s", body)
-	}
-}
-
-func TestDashboard_EmptyState(t *testing.T) {
-	s, _ := newServer(t, "admin", "secret")
-
-	req := httptest.NewRequest(http.MethodGet, "/", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", rec.Code)
-	}
-	if !strings.Contains(rec.Body.String(), "No monitored artists") {
-		t.Errorf("expected empty-state message, got:\n%s", rec.Body.String())
-	}
-}
-
-func TestDashboard_NotFoundForOtherPaths(t *testing.T) {
-	s, _ := newServer(t, "admin", "secret")
-
-	req := httptest.NewRequest(http.MethodGet, "/favicon.ico", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusNotFound {
-		t.Fatalf("expected 404 for non-root path, got %d", rec.Code)
-	}
-}
-
-func TestArtistDetail_RendersLocalAndMissing(t *testing.T) {
-	s, db := newServer(t, "admin", "secret")
-	seedArtist(t, db, "a1", "Radiohead", "mbid-1", true)
-	seedLocalAlbum(t, db, "l1", "a1", "OK Computer")
-	seedLocalAlbum(t, db, "l2", "a1", "The Bends")
-	// One missing release (no local album matches "Kid A").
-	seedExternalRelease(t, db, "r1", "a1", "Kid A")
-
-	req := httptest.NewRequest(http.MethodGet, "/artist/a1", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", rec.Code)
-	}
-	body := rec.Body.String()
-	for _, want := range []string{"Radiohead", "OK Computer", "The Bends", "Kid A", "mbid-1"} {
-		if !strings.Contains(body, want) {
-			t.Errorf("expected %q in artist page, got:\n%s", want, body)
-		}
-	}
-	if !strings.Contains(body, `name="rgid" value="r1"`) {
-		t.Errorf("expected ignore form for r1, got:\n%s", body)
-	}
-}
-
-func TestArtistDetail_UnknownArtist404(t *testing.T) {
-	s, _ := newServer(t, "admin", "secret")
-
-	req := httptest.NewRequest(http.MethodGet, "/artist/does-not-exist", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusNotFound {
-		t.Fatalf("expected 404 for unknown artist, got %d", rec.Code)
-	}
-}
-
-func TestArtistDetail_BarePath404(t *testing.T) {
-	s, _ := newServer(t, "admin", "secret")
-
-	req := httptest.NewRequest(http.MethodGet, "/artist/", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusNotFound {
-		t.Fatalf("expected 404 for bare /artist/, got %d", rec.Code)
-	}
-}
-
-func TestArtistDetail_RequiresGet(t *testing.T) {
-	s, _ := newServer(t, "admin", "secret")
-
-	req := httptest.NewRequest(http.MethodPost, "/artist/a1", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusMethodNotAllowed {
-		t.Fatalf("expected 405 for POST on detail, got %d", rec.Code)
-	}
-}
-
-func TestArchive_RendersIgnoredReleases(t *testing.T) {
-	s, db := newServer(t, "admin", "secret")
-	seedArtist(t, db, "a1", "Radiohead", "", true)
-	// An ignored external release.
-	if err := database.SaveExternalRelease(db, &database.ExternalRelease{
-		RGID:      "r-ignored",
-		ArtistID:  "a1",
-		Title:     "Ignored Album",
-		IsIgnored: true,
-	}); err != nil {
-		t.Fatalf("seed ignored release: %v", err)
-	}
-
-	req := httptest.NewRequest(http.MethodGet, "/archive", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", rec.Code)
-	}
-	body := rec.Body.String()
-	if !strings.Contains(body, "Ignored Album") {
-		t.Errorf("expected ignored release in archive, got:\n%s", body)
-	}
-	if !strings.Contains(body, `name="rgid" value="r-ignored"`) {
-		t.Errorf("expected restore form for r-ignored, got:\n%s", body)
-	}
-}
-
-func TestArchive_EmptyState(t *testing.T) {
-	s, _ := newServer(t, "admin", "secret")
-
-	req := httptest.NewRequest(http.MethodGet, "/archive", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", rec.Code)
-	}
-	if !strings.Contains(rec.Body.String(), "No ignored releases") {
-		t.Errorf("expected empty archive message, got:\n%s", rec.Body.String())
-	}
-}
-
-func TestArchive_RequiresGet(t *testing.T) {
-	s, _ := newServer(t, "admin", "secret")
-
-	req := httptest.NewRequest(http.MethodPost, "/archive", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusMethodNotAllowed {
-		t.Fatalf("expected 405 for POST on archive, got %d", rec.Code)
-	}
-}
-
-func TestIgnoreAction_SetsFlagAndRemovesFromDashboard(t *testing.T) {
-	s, db := newServer(t, "admin", "secret")
-	seedArtist(t, db, "a1", "Radiohead", "", true)
-	seedExternalRelease(t, db, "r1", "a1", "Kid A")
-
-	// Before ignore: dashboard shows 1 missing.
-	before := dashboardMissingCount(t, s, "Radiohead")
-	if before != 1 {
-		t.Fatalf("expected 1 missing before ignore, got %d", before)
-	}
-
-	// POST ignore.
-	form := strings.NewReader("rgid=r1")
-	req := httptest.NewRequest(http.MethodPost, "/artist/a1/ignore", form)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("expected 303 redirect, got %d", rec.Code)
-	}
-	if loc := rec.Header().Get("Location"); loc != "/artist/a1" {
-		t.Errorf("expected redirect to /artist/a1, got %q", loc)
-	}
-
-	// Flag persisted.
-	rel, err := database.GetExternalRelease(db, "r1")
-	if err != nil {
-		t.Fatalf("get release: %v", err)
-	}
-	if !rel.IsIgnored {
-		t.Errorf("expected r1 to be ignored")
-	}
-
-	// Dashboard missing count drops to 0.
-	after := dashboardMissingCount(t, s, "Radiohead")
-	if after != 0 {
-		t.Fatalf("expected 0 missing after ignore, got %d", after)
-	}
-}
-
-func TestIgnoreAction_RequiresAuth(t *testing.T) {
-	s, db := newServer(t, "admin", "secret")
-	seedArtist(t, db, "a1", "Radiohead", "", true)
-	seedExternalRelease(t, db, "r1", "a1", "Kid A")
-
-	form := strings.NewReader("rgid=r1")
-	req := httptest.NewRequest(http.MethodPost, "/artist/a1/ignore", form)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("expected 401 without auth, got %d", rec.Code)
-	}
-	// Flag must remain unset.
-	rel, err := database.GetExternalRelease(db, "r1")
-	if err != nil {
-		t.Fatalf("get release: %v", err)
-	}
-	if rel.IsIgnored {
-		t.Errorf("release must not be ignored without auth")
-	}
-}
-
-func TestRestoreAction_ClearsFlag(t *testing.T) {
-	s, db := newServer(t, "admin", "secret")
-	seedArtist(t, db, "a1", "Radiohead", "", true)
-	if err := database.SaveExternalRelease(db, &database.ExternalRelease{
-		RGID:      "r1",
-		ArtistID:  "a1",
-		Title:     "Kid A",
-		IsIgnored: true,
-	}); err != nil {
-		t.Fatalf("seed ignored release: %v", err)
-	}
-
-	form := strings.NewReader("rgid=r1")
-	req := httptest.NewRequest(http.MethodPost, "/artist/a1/restore", form)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("expected 303 redirect, got %d", rec.Code)
-	}
-	rel, err := database.GetExternalRelease(db, "r1")
-	if err != nil {
-		t.Fatalf("get release: %v", err)
-	}
-	if rel.IsIgnored {
-		t.Errorf("expected r1 to be restored (not ignored)")
-	}
-}
-
-func TestIgnoreSingles_TogglesFlag(t *testing.T) {
-	s, db := newServer(t, "admin", "secret")
-	seedArtist(t, db, "a1", "Radiohead", "", true)
-
-	// Toggle on.
-	req := httptest.NewRequest(http.MethodPost, "/artist/a1/ignore-singles", nil)
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("expected 303 on toggle, got %d", rec.Code)
-	}
-	settings, err := database.GetArtistSettings(db, "a1")
-	if err != nil {
-		t.Fatalf("get settings: %v", err)
-	}
-	if !settings.IgnoreSingles {
-		t.Errorf("expected ignore_singles = true after first toggle")
-	}
-
-	// Toggle off.
-	req2 := httptest.NewRequest(http.MethodPost, "/artist/a1/ignore-singles", nil)
-	req2.SetBasicAuth("admin", "secret")
-	rec2 := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec2, req2)
-	settings, err = database.GetArtistSettings(db, "a1")
-	if err != nil {
-		t.Fatalf("get settings: %v", err)
-	}
-	if settings.IgnoreSingles {
-		t.Errorf("expected ignore_singles = false after second toggle")
-	}
-}
-
-func TestIgnoreSingles_RequiresAuth(t *testing.T) {
-	s, _ := newServer(t, "admin", "secret")
-
-	req := httptest.NewRequest(http.MethodPost, "/artist/a1/ignore-singles", nil)
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("expected 401 without auth, got %d", rec.Code)
-	}
-}
-
-// dashboardMissingCount returns the missing-release count for the artist with
-// the given name from the dashboard view model (0 if the artist is absent).
-func dashboardMissingCount(t *testing.T, s *Server, artistName string) int {
-	t.Helper()
-	data, err := s.buildDashboardData(context.Background(), 0)
-	if err != nil {
-		t.Fatalf("build dashboard data: %v", err)
-	}
-	for _, a := range data.Artists {
-		if a.Name == artistName {
-			return a.MissingCount
-		}
-	}
-	return 0
-}
-
-// postStateChanging issues a state-changing POST to the given route with the
-// provided Origin/Referer header and basic auth, returning the response code.
-func postStateChanging(t *testing.T, s *Server, path, originHeader string) int {
-	t.Helper()
-	form := strings.NewReader("rgid=r1")
-	req := httptest.NewRequest(http.MethodPost, path, form)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	if originHeader != "" {
-		req.Header.Set("Origin", originHeader)
-	}
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-	return rec.Code
-}
-
-func TestStateChangingEnforcesSameOrigin(t *testing.T) {
-	served := "http://0.0.0.0:8080" // matches the server's Addr()
-
-	tests := []struct {
-		name     string
-		route    string
-		origin   string
-		wantCode int
-	}{
-		{"same-origin Origin allowed", "/artist/a1/ignore", served, http.StatusSeeOther},
-		{"no Origin header allowed (same-origin form post)", "/artist/a1/ignore", "", http.StatusSeeOther},
-		{"cross-origin Origin rejected", "/artist/a1/ignore", "http://evil.example", http.StatusForbidden},
-		{"cross-origin Referer rejected", "/artist/a1/ignore", "", http.StatusForbidden},
-		{"cross-origin on toggle rejected", "/artist/a1/ignore-singles", "http://evil.example", http.StatusForbidden},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			s, db := newServer(t, "admin", "secret")
-			seedArtist(t, db, "a1", "Radiohead", "", true)
-			seedExternalRelease(t, db, "r1", "a1", "Kid A")
-
-			// For the cross-origin Referer case, use Referer instead of Origin.
-			var code int
-			if tt.name == "cross-origin Referer rejected" {
-				form := strings.NewReader("rgid=r1")
-				req := httptest.NewRequest(http.MethodPost, tt.route, form)
-				req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-				req.Header.Set("Referer", "http://evil.example/artist/a1")
-				req.SetBasicAuth("admin", "secret")
-				rec := httptest.NewRecorder()
-				s.Handler().ServeHTTP(rec, req)
-				code = rec.Code
-			} else {
-				code = postStateChanging(t, s, tt.route, tt.origin)
-			}
-
-			if code != tt.wantCode {
-				t.Fatalf("route %s origin %q: got %d, want %d", tt.route, tt.origin, code, tt.wantCode)
-			}
-		})
-	}
-}
-
-func TestStateChanging_MalformedOriginRejected(t *testing.T) {
-	s, db := newServer(t, "admin", "secret")
-	seedArtist(t, db, "a1", "Radiohead", "", true)
-	seedExternalRelease(t, db, "r1", "a1", "Kid A")
-
-	form := strings.NewReader("rgid=r1")
-	req := httptest.NewRequest(http.MethodPost, "/artist/a1/ignore", form)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	// An Origin that does not parse as a valid URL with a host.
-	req.Header.Set("Origin", "http://")
-	req.SetBasicAuth("admin", "secret")
-	rec := httptest.NewRecorder()
-	s.Handler().ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("expected 403 for malformed origin, got %d", rec.Code)
-	}
-}

internal/web/templates/archive.html

@@ -1,48 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>NaviWatcher — Archive</title>
-    <style>
-        body { font-family: system-ui, sans-serif; margin: 2rem; color: #1a1a1a; }
-        h1 { margin-bottom: 0.25rem; }
-        a { color: #1565c0; }
-        table { border-collapse: collapse; width: 100%; }
-        th, td { text-align: left; padding: 0.5rem 0.75rem; border-bottom: 1px solid #e2e2e2; }
-        th { background: #f6f6f6; }
-        .empty { color: #888; font-style: italic; }
-        form { display: inline; }
-    </style>
-</head>
-<body>
-    <p><a href="/">&larr; Dashboard</a></p>
-    <h1>Ignored releases</h1>
-
-    {{ if .Releases }}
-    <table>
-        <thead>
-            <tr><th>Artist</th><th>Title</th><th>Type</th><th>Date</th><th>Action</th></tr>
-        </thead>
-        <tbody>
-        {{ range .Releases }}
-            <tr>
-                <td>{{ if .ArtistName }}{{ .ArtistName }}{{ else }}{{ .ArtistID }}{{ end }}</td>
-                <td>{{ .Title }}</td>
-                <td>{{ if .Type }}{{ .Type }}{{ else }}<span class="empty">—</span>{{ end }}</td>
-                <td>{{ if .ReleaseDate }}{{ .ReleaseDate }}{{ else }}<span class="empty">—</span>{{ end }}</td>
-                <td>
-                    <form method="POST" action="/artist/{{ .ArtistID }}/restore">
-                        <input type="hidden" name="rgid" value="{{ .RGID }}">
-                        <button type="submit">Restore</button>
-                    </form>
-                </td>
-            </tr>
-        {{ end }}
-        </tbody>
-    </table>
-    {{ else }}
-    <p class="empty">No ignored releases.</p>
-    {{ end }}
-</body>
-</html>

internal/web/templates/artist.html

@@ -1,88 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>NaviWatcher — {{ .Name }}</title>
-    <style>
-        body { font-family: system-ui, sans-serif; margin: 2rem; color: #1a1a1a; }
-        h1 { margin-bottom: 0.25rem; }
-        .sub { color: #666; margin-bottom: 1.5rem; }
-        a { color: #1565c0; }
-        table { border-collapse: collapse; width: 100%; margin-bottom: 2rem; }
-        th, td { text-align: left; padding: 0.5rem 0.75rem; border-bottom: 1px solid #e2e2e2; }
-        th { background: #f6f6f6; }
-        .empty { color: #888; font-style: italic; }
-        .missing { color: #c62828; }
-        .ignored { color: #888; text-decoration: line-through; }
-        .toggle { display: inline-block; margin-bottom: 1rem; }
-        form { display: inline; }
-        button { cursor: pointer; }
-    </style>
-</head>
-<body>
-    <p><a href="/">&larr; Dashboard</a></p>
-    <h1>{{ .Name }}</h1>
-    <div class="sub">MusicBrainz: {{ if .MBID }}{{ .MBID }}{{ else }}<span class="empty">—</span>{{ end }}</div>
-
-    <form class="toggle" method="POST" action="/artist/{{ .ID }}/ignore-singles">
-        <button type="submit">{{ if .IgnoreSingles }}Enable singles{{ else }}Ignore all singles{{ end }}</button>
-        {{ if .IgnoreSingles }}<span class="sub"> (singles currently ignored)</span>{{ end }}
-    </form>
-
-    <form class="toggle" method="POST" action="/artist/{{ .ID }}/ignore-compilations">
-        <button type="submit">{{ if .IgnoreCompilations }}Enable compilations{{ else }}Ignore all compilations{{ end }}</button>
-        {{ if .IgnoreCompilations }}<span class="sub"> (compilations currently ignored)</span>{{ end }}
-    </form>
-
-    <form class="toggle" method="POST" action="/artist/{{ .ID }}/ignore-live">
-        <button type="submit">{{ if .IgnoreLive }}Enable live{{ else }}Ignore all live{{ end }}</button>
-        {{ if .IgnoreLive }}<span class="sub"> (live recordings currently ignored)</span>{{ end }}
-    </form>
-
-    <form class="toggle" method="POST" action="/artist/{{ .ID }}/ignore-remix">
-        <button type="submit">{{ if .IgnoreRemix }}Enable remixes{{ else }}Ignore all remixes{{ end }}</button>
-        {{ if .IgnoreRemix }}<span class="sub"> (remixes currently ignored)</span>{{ end }}
-    </form>
-
-    <h2>Local albums (Subsonic)</h2>
-    {{ if .LocalAlbums }}
-    <table>
-        <thead><tr><th>Title</th></tr></thead>
-        <tbody>
-        {{ range .LocalAlbums }}
-            <tr><td>{{ .Title }}</td></tr>
-        {{ end }}
-        </tbody>
-    </table>
-    {{ else }}
-    <p class="empty">No local albums synced for this artist.</p>
-    {{ end }}
-
-    <h2>Found missing (MusicBrainz)</h2>
-    {{ if .Missing }}
-    <table>
-        <thead>
-            <tr><th>Title</th><th>Type</th><th>Date</th><th>Action</th></tr>
-        </thead>
-        <tbody>
-        {{ range .Missing }}
-            <tr class="{{ if .Ignored }}ignored{{ else }}missing{{ end }}">
-                <td>{{ .Title }}</td>
-                <td>{{ if .Type }}{{ .Type }}{{ else }}<span class="empty">—</span>{{ end }}</td>
-                <td>{{ if .ReleaseDate }}{{ .ReleaseDate }}{{ else }}<span class="empty">—</span>{{ end }}</td>
-                <td>
-                    <form method="POST" action="/artist/{{ $.ID }}/ignore">
-                        <input type="hidden" name="rgid" value="{{ .RGID }}">
-                        <button type="submit">Ignore</button>
-                    </form>
-                </td>
-            </tr>
-        {{ end }}
-        </tbody>
-    </table>
-    {{ else }}
-    <p class="empty">No missing releases for this artist.</p>
-    {{ end }}
-</body>
-</html>

internal/web/templates/dashboard.html

@@ -1,49 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>NaviWatcher — Dashboard</title>
-    <style>
-        body { font-family: system-ui, sans-serif; margin: 2rem; color: #1a1a1a; }
-        h1 { margin-bottom: 0.25rem; }
-        .sub { color: #666; margin-bottom: 1.5rem; }
-        table { border-collapse: collapse; width: 100%; }
-        th, td { text-align: left; padding: 0.5rem 0.75rem; border-bottom: 1px solid #e2e2e2; }
-        th { background: #f6f6f6; }
-        .count { font-weight: bold; }
-        .count-zero { color: #2e7d32; }
-        .count-missing { color: #c62828; }
-        .empty { color: #888; font-style: italic; }
-    </style>
-</head>
-<body>
-    <h1>NaviWatcher</h1>
-    <div class="sub">Monitored artists: {{ len .Artists }} · Missing releases: {{ .TotalMissing }} · <a href="/archive">Archive</a></div>
-
-    {{ if .Artists }}
-    <table>
-        <thead>
-            <tr>
-                <th>Artist</th>
-                <th>Missing</th>
-                <th>MusicBrainz</th>
-            </tr>
-        </thead>
-        <tbody>
-            {{ range .Artists }}
-            <tr>
-                <td><a href="/artist/{{ .ID }}">{{ .Name }}</a></td>
-                <td class="count {{ if eq .MissingCount 0 }}count-zero{{ else }}count-missing{{ end }}">
-                    {{ .MissingCount }}
-                </td>
-                <td>{{ if .MBID }}{{ .MBID }}{{ else }}<span class="empty">—</span>{{ end }}</td>
-            </tr>
-            {{ end }}
-        </tbody>
-    </table>
-    {{ else }}
-    <p class="empty">No monitored artists yet. Run a sync to populate the dashboard.</p>
-    {{ end }}
-</body>
-</html>